From f08146e7b747600b90ea31ac2f55c90cefd29e84 Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Tue, 1 Jul 2025 22:25:46 +0800 Subject: [PATCH 1/6] modify component set option methods in attribute interface Signed-off-by: VictorS67 Change-Id: Id01bf58156a75320e9fe2cf1a74fa37f69684751 --- .../collectors/utils/collect-types.ts | 240 +++++++++++++++++ arkui-plugins/common/safe-types.ts | 8 +- .../decorators/state/state-basic-type.test.ts | 4 - .../builder-lambda-translators/factory.ts | 251 +++++++++++++++--- .../style-internals-visitor.ts | 51 ++++ .../builder-lambda-translators/utils.ts | 154 ++++++++++- .../ui-plugins/checked-transformer.ts | 22 +- .../ui-plugins/struct-translators/factory.ts | 23 +- .../ui-plugins/type-translators/factory.ts | 216 +++++++++++++++ arkui-plugins/ui-plugins/utils.ts | 4 +- .../src/arkts-api/factory/nodeFactory.ts | 32 +++ koala-wrapper/src/arkts-api/index.ts | 1 + .../arkts-api/node-utilities/ETSNullType.ts | 26 ++ .../arkts-api/node-utilities/TSArrayType.ts | 32 +++ .../node-utilities/TSQualifiedName.ts | 31 +++ .../arkts-api/node-utilities/TSThisType.ts | 26 ++ koala-wrapper/src/arkts-api/types.ts | 2 +- 17 files changed, 1057 insertions(+), 66 deletions(-) create mode 100644 arkui-plugins/collectors/utils/collect-types.ts create mode 100644 arkui-plugins/ui-plugins/builder-lambda-translators/style-internals-visitor.ts create mode 100644 arkui-plugins/ui-plugins/type-translators/factory.ts create mode 100644 koala-wrapper/src/arkts-api/node-utilities/ETSNullType.ts create mode 100644 koala-wrapper/src/arkts-api/node-utilities/TSArrayType.ts create mode 100644 koala-wrapper/src/arkts-api/node-utilities/TSQualifiedName.ts create mode 100644 koala-wrapper/src/arkts-api/node-utilities/TSThisType.ts diff --git a/arkui-plugins/collectors/utils/collect-types.ts b/arkui-plugins/collectors/utils/collect-types.ts new file mode 100644 index 000000000..73a3319ee --- /dev/null +++ b/arkui-plugins/collectors/utils/collect-types.ts @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as arkts from '@koalaui/libarkts'; + +export enum TypeRecordTypes { + PRIMITIVE, + FUNCTION, + UNION, + UNDEFINED, + NULL, + TYPE_REFERENCE, + TYPE_PARAMETER, + THIS, + ARRAY, +} + +export interface ThisTypeRecord { + type: TypeRecordTypes.THIS; +} + +export interface ArrayTypeRecord { + type: TypeRecordTypes.ARRAY; + elementType?: TypeRecord; +} + +export interface UndefinedTypeRecord { + type: TypeRecordTypes.UNDEFINED; +} + +export interface NullTypeRecord { + type: TypeRecordTypes.NULL; +} + +export interface TypeReferenceTypeRecord { + type: TypeRecordTypes.TYPE_REFERENCE; + typeName: string | string[]; + annotations: readonly arkts.AnnotationUsage[]; + typeParams?: TypeRecord[]; +} + +export interface PrimitiveTypeRecord { + type: TypeRecordTypes.PRIMITIVE; + typeName: string; +} + +export interface FunctionTypeRecord { + type: TypeRecordTypes.FUNCTION; + params: ParameterRecord[]; + returnType: TypeRecord; + annotations: readonly arkts.AnnotationUsage[]; + typeParams?: TypeParameterTypeRecord[]; +} + +export interface UnionTypeRecord { + type: TypeRecordTypes.UNION; + types: TypeRecord[]; +} + +export interface TypeParameterTypeRecord { + type: TypeRecordTypes.TYPE_PARAMETER; + annotations: readonly arkts.AnnotationUsage[]; + typeName?: string; + constraint?: TypeRecord; + defaultType?: TypeRecord; +} + +export type TypeRecord = + | ArrayTypeRecord + | ThisTypeRecord + | UndefinedTypeRecord + | NullTypeRecord + | TypeReferenceTypeRecord + | PrimitiveTypeRecord + | FunctionTypeRecord + | UnionTypeRecord; + +export interface ParameterRecord { + name: string; + typeRecord: TypeRecord; + annotations: readonly arkts.AnnotationUsage[]; + isOptional: boolean; +} + +export function collectTypeRecordFromTypeParameterInstatiation( + typeParams: arkts.TSTypeParameterInstantiation | undefined +): TypeRecord[] | undefined { + if (!typeParams) { + return undefined; + } + return typeParams.params.map((p) => collectTypeRecordFromType(p)!); +} + +export function collectTypeRecordFromTypeParameterDeclaration( + typeParams: arkts.TSTypeParameterDeclaration | undefined +): TypeParameterTypeRecord[] | undefined { + if (!typeParams) { + return undefined; + } + return typeParams.params.map((p) => collectTypeRecordFromTypeParameter(p)); +} + +export function collectTypeRecordFromTypeParameter(typeParameter: arkts.TSTypeParameter): TypeParameterTypeRecord { + const type = TypeRecordTypes.TYPE_PARAMETER; + const typeName = typeParameter.name?.name; + const annotations = typeParameter.annotations; + const constraint = collectTypeRecordFromType(typeParameter.constraint); + const defaultType = collectTypeRecordFromType(typeParameter.defaultType); + return { type, typeName, annotations, constraint, defaultType }; +} + +export function collectTypeRecordFromUnionType(unionType: arkts.TSUnionType): UnionTypeRecord { + const type = TypeRecordTypes.UNION; + const types = unionType.types.map((t) => collectTypeRecordFromType(t)!); + return { type, types }; +} + +export function collectTypeRecordFromFunctionType(funcType: arkts.ETSFunctionType): FunctionTypeRecord { + const type = TypeRecordTypes.FUNCTION; + const params = funcType.params.map((p) => collectTypeRecordFromParameter(p as arkts.ETSParameterExpression)); + const returnType = collectTypeRecordFromType(funcType.returnType)!; + const annotations = funcType.annotations; + const typeParams = collectTypeRecordFromTypeParameterDeclaration(funcType.typeParams); + return { type, params, returnType, annotations, typeParams }; +} + +export function collectTypeRecordFromParameter(param: arkts.ETSParameterExpression): ParameterRecord { + const name = param.identifier.name; + const typeRecord = collectTypeRecordFromType(param.type)!; + const annotations = param.annotations; + const isOptional = param.optional; + return { name, typeRecord, annotations, isOptional }; +} + +function coerceTypeNameToArray(name: string | string[] | undefined): string[] { + if (Array.isArray(name)) { + return name; + } + if (!!name) { + return [name]; + } + return []; +} + +function getTypeNameFromTypeReferencePartName(name: arkts.Expression | undefined): string | string[] | undefined { + if (!name) { + return undefined; + } + if (arkts.isIdentifier(name)) { + return name.name; + } + if (arkts.isTSQualifiedName(name)) { + const leftName: string | string[] | undefined = getTypeNameFromTypeReferencePartName(name.left); + const rightName: string | string[] | undefined = getTypeNameFromTypeReferencePartName(name.right); + const nameArr: string[] = [...coerceTypeNameToArray(leftName), ...coerceTypeNameToArray(rightName)]; + if (nameArr.length === 0) { + return undefined; + } + return nameArr; + } + return undefined; +} + +export function collectTypeRecordFromTypeReference(node: arkts.ETSTypeReference): TypeReferenceTypeRecord | undefined { + if (!node.part || !arkts.isETSTypeReferencePart(node.part)) { + return undefined; + } + if (!node.part.name) { + return undefined; + } + const typeName = getTypeNameFromTypeReferencePartName(node.part.name); + if (!typeName) { + return undefined; + } + const type = TypeRecordTypes.TYPE_REFERENCE; + const annotations = node.annotations; + const typeParams = collectTypeRecordFromTypeParameterInstatiation(node.part.typeParams); + return { type, typeName, annotations, typeParams }; +} + +export function collectTypeRecordFromUndefinedType(node: arkts.ETSUndefinedType): UndefinedTypeRecord { + const type = TypeRecordTypes.UNDEFINED; + return { type }; +} + +export function collectTypeRecordFromNullType(node: arkts.ETSNullType): NullTypeRecord { + const type = TypeRecordTypes.NULL; + return { type }; +} + +export function collectTypeRecordFromThisType(node: arkts.TSThisType): ThisTypeRecord { + const type = TypeRecordTypes.THIS; + return { type }; +} + +export function collectTypeRecordFromArrayType(node: arkts.TSArrayType): ArrayTypeRecord { + const type = TypeRecordTypes.ARRAY; + const elementType = collectTypeRecordFromType(node.elementType); + return { type, elementType }; +} + +export function collectTypeRecordFromPrimitiveType(node: arkts.ETSPrimitiveType): PrimitiveTypeRecord | undefined { + const type = TypeRecordTypes.PRIMITIVE; + const typeName: string = node.dumpSrc(); + return { type, typeName }; +} + +export function collectTypeRecordFromType(node: arkts.AstNode | undefined): TypeRecord | undefined { + if (!node) { + return undefined; + } + const type = arkts.nodeType(node); + if (collectTypeRecordByType.has(type)) { + return collectTypeRecordByType.get(type)!(node); + } + return undefined; +} + +const collectTypeRecordByType = new Map TypeRecord | undefined>([ + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, collectTypeRecordFromTypeReference], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, collectTypeRecordFromFunctionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, collectTypeRecordFromUndefinedType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, collectTypeRecordFromPrimitiveType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, collectTypeRecordFromNullType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, collectTypeRecordFromUnionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, collectTypeRecordFromThisType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, collectTypeRecordFromArrayType], +]); diff --git a/arkui-plugins/common/safe-types.ts b/arkui-plugins/common/safe-types.ts index 899ef0c39..09ccd9092 100644 --- a/arkui-plugins/common/safe-types.ts +++ b/arkui-plugins/common/safe-types.ts @@ -34,10 +34,12 @@ export type PartialNested = { type NestedKey = { [P in keyof T]: P extends K ? T[P] : T[P] extends object ? NestedKey : T[P]; - }; - +}; + export type PickNested = { [P in keyof T]: P extends K ? T[P] : T[P] extends object ? NestedKey : T[P]; }; -export type PartialNestedExcept = PartialNested> & PickNested; \ No newline at end of file +export type PartialNestedExcept = PartialNested> & PickNested; + +export type AstNodePointer = arkts.AstNode['peer']; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts index c47bd027b..fa8ae1076 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts @@ -167,10 +167,6 @@ function main() {} `; function testParsedAndCheckedTransformer(this: PluginTestContext): void { - console.log("[testParsedAndCheckedTransformer] this: ", this); - console.log("[testParsedAndCheckedTransformer] parseDumpSrc(this.scriptSnapshot ?? ''): ", parseDumpSrc(this.scriptSnapshot ?? '')); - console.log("[testParsedAndCheckedTransformer] parseDumpSrc(expectedScript): ", parseDumpSrc(expectedScript)); - expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); } diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts index 4aede6309..c5a887999 100644 --- a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts @@ -44,12 +44,25 @@ import { BuilderLambdaSecondLastArgInfo, buildSecondLastArgInfo, checkIsSpecialComponentAttributeFromType, + ComponentAttributeCache, + ComponentRecord, + getDeclaredSetAttribtueMethodName, + BuilderLambdaStyleBodyInfo, + checkIsTrailingLambdaInLastParam, + filterParamsExpectTrailingLambda, } from './utils'; import { isDecoratorIntrinsicAnnotation } from '../property-translators/utils'; import { factory as PropertyFactory } from '../property-translators/factory'; +import { factory as TypeFactory } from '../type-translators/factory'; +import { factory as UIFactory } from '../ui-factory'; import { AnimationNames, BindableDecl, DecoratorIntrinsicNames, DecoratorNames } from '../../common/predefines'; import { ImportCollector } from '../../common/import-collector'; -import { addMemoAnnotation, collectMemoableInfoInParameter } from '../../collectors/memo-collectors/utils'; +import { + addMemoAnnotation, + checkIsMemoFromMemoableInfo, + collectMemoableInfoInParameter, +} from '../../collectors/memo-collectors/utils'; +import { StyleInternalsVisitor } from './style-internals-visitor'; export class factory { /** @@ -59,14 +72,12 @@ export class factory { node: arkts.MethodDefinition, prefixArgs: arkts.ETSParameterExpression[], newAnno: arkts.AnnotationUsage[], - newName: string | undefined, - externalSourceName?: string + newName: string | undefined ): arkts.MethodDefinition { const func: arkts.ScriptFunction = node.scriptFunction; - let newParams: arkts.Expression[] = []; - if (func.params.length > 0) { - newParams.push(...prefixArgs, ...func.params); - } + const isFunctionCall: boolean = node.name.name !== BuilderLambdaNames.ORIGIN_METHOD_NAME; + const restParams = isFunctionCall ? filterParamsExpectTrailingLambda(func.params) : func.params; + const newParams: arkts.Expression[] = [...prefixArgs, ...restParams]; const updateFunc = arkts.factory .updateScriptFunction( func, @@ -86,7 +97,7 @@ export class factory { node, node.kind, arkts.factory.updateIdentifier(node.name, newName ?? node.name.name), - node.name.name === BuilderLambdaNames.ORIGIN_METHOD_NAME ? addMemoAnnotation(updateFunc) : updateFunc, + isFunctionCall ? updateFunc : addMemoAnnotation(updateFunc), node.modifiers, false ); @@ -158,6 +169,39 @@ export class factory { } } + /** + * add `instance.()` call as the initial style argument body for components. + * The initial style argument body is `undefined` for custom components. + */ + static createInitLambdaBody(declInfo: BuilderLambdaDeclInfo): BuilderLambdaStyleBodyInfo { + const { name, isFunctionCall, hasReceiver } = declInfo; + const lambdaBodyInfo: BuilderLambdaStyleBodyInfo = { lambdaBody: undefined, initCallPtr: undefined }; + if (!isFunctionCall) { + return lambdaBodyInfo; + } + let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier( + BuilderLambdaNames.STYLE_ARROW_PARAM_NAME + ); + const methodName = arkts.factory.createIdentifier(getDeclaredSetAttribtueMethodName(name)); + if (!hasReceiver) { + lambdaBodyInfo.lambdaBody = arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + lambdaBody, + methodName, + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [] + ); + } else { + lambdaBodyInfo.lambdaBody = arkts.factory.createCallExpression(methodName, undefined, [lambdaBody]); + } + lambdaBodyInfo.initCallPtr = lambdaBodyInfo.lambdaBody.peer; + return lambdaBodyInfo; + } + /* * update parameter passing, e.g. `: __backing_`. */ @@ -287,7 +331,7 @@ export class factory { /** * transform options argument in a builder lambda call. */ - static processOptionsArg(arg: T, typeName: string): T { + static processOptionsArg(arg: T): T { let expr: arkts.ObjectExpression | undefined; if (arkts.isTSAsExpression(arg) && !!arg.expr && arkts.isObjectExpression(arg.expr)) { expr = arg.expr; @@ -352,7 +396,6 @@ export class factory { static createOrUpdateArgInBuilderLambda( fallback: arkts.AstNode | undefined, arg: arkts.Expression | undefined, - typeName?: string, canAddMemo?: boolean ): arkts.AstNode | undefined { if (!arg) { @@ -367,7 +410,7 @@ export class factory { } // this is too optimistic to check if this is an options argument... if (arkts.isTSAsExpression(arg) || arkts.isObjectExpression(arg)) { - return this.processOptionsArg(arg, typeName!); + return this.processOptionsArg(arg); } return arg; } @@ -387,16 +430,16 @@ export class factory { */ static generateArgsInBuilderLambda( leaf: arkts.CallExpression, - lambdaBody: arkts.Identifier | arkts.CallExpression, + lambdaBodyInfo: BuilderLambdaStyleBodyInfo, declInfo: BuilderLambdaDeclInfo ): (arkts.AstNode | undefined)[] { const { isFunctionCall, params, returnType, moduleName } = declInfo; const type: arkts.Identifier | undefined = builderLambdaType(leaf); - const args: (arkts.AstNode | undefined)[] = [ - this.createStyleArgInBuilderLambda(lambdaBody, returnType, moduleName, leaf.typeArguments?.at(0)), - ]; + const args: (arkts.AstNode | undefined)[] = []; + const modifiedArgs: (arkts.AstNode | undefined)[] = []; const secondLastArgInfo = buildSecondLastArgInfo(type, isFunctionCall); const isTrailingCall = leaf.isTrailingCall; + const hasLastTrailingLambda = checkIsTrailingLambdaInLastParam(params); forEachArgWithParam( leaf.arguments, params, @@ -407,20 +450,67 @@ export class factory { } if (!modifiedArg) { const memoableInfo = collectMemoableInfoInParameter(param); - const canAddMemo = - (!!memoableInfo.hasBuilder || !!memoableInfo.hasMemo) && !!memoableInfo.hasProperType; - modifiedArg = this.createOrUpdateArgInBuilderLambda( - arkts.factory.createUndefinedLiteral(), - arg, - type?.name, - canAddMemo - ); + const canAddMemo = checkIsMemoFromMemoableInfo(memoableInfo, false); + const fallback = arkts.factory.createUndefinedLiteral(); + modifiedArg = this.createOrUpdateArgInBuilderLambda(fallback, arg, canAddMemo); + } + const shouldInsertToArgs = !isFunctionCall || (index === params.length - 1 && hasLastTrailingLambda); + if (shouldInsertToArgs) { + args.push(modifiedArg); + } else { + modifiedArgs.push(modifiedArg); } - args.push(modifiedArg); }, { isTrailingCall } ); - return filterDefined(args); + const lambdaBody = this.addOptionsArgsToLambdaBodyInStyleArg(lambdaBodyInfo, modifiedArgs, leaf.typeArguments); + const typeNode = !isFunctionCall && !!type ? UIFactory.createTypeReferenceFromString(type.name) : returnType; + const styleArg = this.createStyleArgInBuilderLambda(lambdaBody, typeNode, moduleName, leaf.typeArguments?.at(0)); + args.unshift(styleArg); + return args; + } + + /** + * add options arguments to set methods in style argument body. + */ + static addOptionsArgsToLambdaBodyInStyleArg( + lambdaBodyInfo: BuilderLambdaStyleBodyInfo, + args: (arkts.AstNode | undefined)[], + typeArguments: readonly arkts.TypeNode[] | undefined + ): arkts.CallExpression | arkts.Identifier | undefined { + const { lambdaBody, initCallPtr } = lambdaBodyInfo; + if (!lambdaBody) { + return undefined; + } + if (!initCallPtr || arkts.isIdentifier(lambdaBody)) { + return this.addApplyAttributesFinishToLambdaBodyEnd(lambdaBody); + } + const styleInternalsVisitor = new StyleInternalsVisitor(); + const newLambdaBody = styleInternalsVisitor + .registerInitCall(initCallPtr) + .registerInitCallArgs(filterDefined(args)) + .registerInitCallTypeArguments(typeArguments) + .visitor(lambdaBody) as arkts.CallExpression | arkts.Identifier; + return this.addApplyAttributesFinishToLambdaBodyEnd(newLambdaBody); + } + + /** + * add `.applyAttributesFinish()` at the end of style argument body. + */ + static addApplyAttributesFinishToLambdaBodyEnd( + lambdaBody: arkts.CallExpression | arkts.Identifier + ): arkts.CallExpression | arkts.Identifier { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + lambdaBody, + arkts.factory.createIdentifier(BuilderLambdaNames.APPLY_ATTRIBUTES_FINISH_METHOD), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [] + ); } /** @@ -494,23 +584,21 @@ export class factory { /** * transform `@ComponentBuilder` in declared methods. */ - static transformBuilderLambdaMethodDecl( - node: arkts.MethodDefinition, - externalSourceName?: string - ): arkts.MethodDefinition { + static transformBuilderLambdaMethodDecl(node: arkts.MethodDefinition): arkts.MethodDefinition { const func: arkts.ScriptFunction = node.scriptFunction; const isFunctionCall: boolean = isBuilderLambdaFunctionCall(node); + if (isFunctionCall) { + ComponentAttributeCache.getInstance().collect(node); + } const typeNode: arkts.TypeNode | undefined = builderLambdaMethodDeclType(node); const newOverloads: arkts.MethodDefinition[] = node.overloads.map((method) => factory.transformBuilderLambdaMethodDecl(method) ); - const newNode = this.updateBuilderLambdaMethodDecl( node, [this.createStyleArgInBuilderLambdaDecl(typeNode, isFunctionCall)], removeAnnotationByName(func.annotations, BuilderLambdaNames.ANNOTATION_NAME), - replaceBuilderLambdaDeclMethodName(node.name.name), - externalSourceName + replaceBuilderLambdaDeclMethodName(node.name.name) ).setOverloads(newOverloads); arkts.NodeCache.getInstance().collect(newNode); return newNode; @@ -556,7 +644,6 @@ export class factory { static transformBuilderLambda(node: arkts.CallExpression): arkts.AstNode { let instanceCalls: InstanceCallInfo[] = []; let leaf: arkts.CallExpression = node; - while (isStyleChainedCall(leaf) || isStyleWithReceiverCall(leaf)) { if (isStyleChainedCall(leaf)) { instanceCalls.push({ @@ -569,7 +656,6 @@ export class factory { }); leaf = (leaf.expression as arkts.MemberExpression).object as arkts.CallExpression; } - if (isStyleWithReceiverCall(leaf)) { instanceCalls.push({ isReceiver: true, @@ -578,30 +664,26 @@ export class factory { leaf = leaf.arguments[0] as arkts.CallExpression; } } - const decl: arkts.AstNode | undefined = findBuilderLambdaDecl(leaf); if (!decl) { return node; } - const replace: arkts.Identifier | arkts.MemberExpression | undefined = this.builderLambdaReplace(leaf); const declInfo: BuilderLambdaDeclInfo | undefined = findBuilderLambdaDeclInfo(decl); if (!replace || !declInfo) { return node; } - - let lambdaBody: arkts.Identifier | arkts.CallExpression | undefined; + const lambdaBodyInfo = factory.createInitLambdaBody(declInfo); + let lambdaBody: arkts.Identifier | arkts.CallExpression | undefined = lambdaBodyInfo.lambdaBody; if (instanceCalls.length > 0) { instanceCalls = instanceCalls.reverse(); this.updateAnimation(instanceCalls); - lambdaBody = arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_ARROW_PARAM_NAME); - arkts.NodeCache.getInstance().collect(lambdaBody); instanceCalls.forEach((callInfo) => { lambdaBody = this.createStyleLambdaBody(lambdaBody!, callInfo); }); } - - const args: (arkts.AstNode | undefined)[] = this.generateArgsInBuilderLambda(leaf, lambdaBody!, declInfo); + lambdaBodyInfo.lambdaBody = lambdaBody; + const args: (arkts.AstNode | undefined)[] = this.generateArgsInBuilderLambda(leaf, lambdaBodyInfo, declInfo); const newNode = arkts.factory.updateCallExpression(node, replace, leaf.typeArguments, filterDefined(args)); arkts.NodeCache.getInstance().collect(newNode); return newNode; @@ -689,4 +771,89 @@ export class factory { ) ); } + + /** + * add declared set methods in `@ComponentBuilder` Attribute interface + */ + static addDeclaredSetMethodsInAttributeInterface(node: arkts.TSInterfaceDeclaration): arkts.TSInterfaceDeclaration { + if (!node.body) { + return node; + } + const records = ComponentAttributeCache.getInstance().getAllComponentRecords(); + if (records.length === 0) { + return node; + } + let rootMethod = factory.createDeclaredSetMethodFromRecord(records.at(0)!); + const overloads: arkts.MethodDefinition[] = []; + for (let i = 0; i < records.length - 1; i++) { + const newMethod = factory.createDeclaredSetMethodFromRecord(records.at(i + 1)!); + overloads.push(newMethod); + } + rootMethod.setOverloads(overloads); + return arkts.factory.updateInterfaceDeclaration( + node, + node.extends, + node.id, + node.typeParams, + arkts.factory.updateInterfaceBody(node.body, [...node.body.body, rootMethod]), + node.isStatic, + node.isFromExternal + ); + } + + /** + * generate declared set method from `ComponentRecord` + */ + static createDeclaredSetMethodFromRecord(record: ComponentRecord): arkts.MethodDefinition { + const name = getDeclaredSetAttribtueMethodName(record.name); + const hasReceiver = !!record.hasReceiver; + const params = record.attributeRecords.map((record) => TypeFactory.createParameterFromRecord(record)); + const typeParams = record.typeParams?.map((p) => TypeFactory.createTypeParameterFromRecord(p)); + + const key = arkts.factory.createIdentifier(name); + const kind = arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD; + const modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE; + const funcTypeParams = typeParams + ? arkts.factory.createTypeParameterDeclaration(typeParams, typeParams.length) + : undefined; + const returnTypeAnnotation = arkts.factory.createTSThisType(); + const flags = arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD; + + return UIFactory.createMethodDefinition({ + key, + kind, + function: { + key, + flags, + params, + typeParams: funcTypeParams, + returnTypeAnnotation, + modifiers, + hasReceiver, + }, + modifiers, + }); + } + + /** + * generate `applyAttributesFinish(): void;` in `CommonMethod` interface + */ + static createDeclaredApplyAttributesFinish(): arkts.MethodDefinition { + const key = arkts.factory.createIdentifier(BuilderLambdaNames.APPLY_ATTRIBUTES_FINISH_METHOD); + const kind = arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD; + const modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE; + const returnTypeAnnotation = arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID); + const flags = arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD; + return UIFactory.createMethodDefinition({ + key, + kind, + function: { + key, + flags, + returnTypeAnnotation, + modifiers + }, + modifiers + }) + } } diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/style-internals-visitor.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/style-internals-visitor.ts new file mode 100644 index 000000000..fc46594bf --- /dev/null +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/style-internals-visitor.ts @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as arkts from '@koalaui/libarkts'; +import { AbstractVisitor } from '../../common/abstract-visitor'; +import { AstNodePointer } from '../../common/safe-types'; + +export class StyleInternalsVisitor extends AbstractVisitor { + private initCallPtr: AstNodePointer | undefined; + private initCallArgs: arkts.AstNode[] | undefined; + private initCallTypeArguments: readonly arkts.TypeNode[] | undefined; + + registerInitCall(initCallPtr: AstNodePointer): this { + this.initCallPtr = initCallPtr; + return this; + } + + registerInitCallArgs(initCallArgs: arkts.AstNode[]): this { + this.initCallArgs = initCallArgs; + return this; + } + + registerInitCallTypeArguments(initCallTypeArguments: readonly arkts.TypeNode[] | undefined): this { + this.initCallTypeArguments = initCallTypeArguments; + return this; + } + + visitor(node: arkts.CallExpression): arkts.AstNode { + if (!!this.initCallPtr && !!this.initCallArgs && node.peer === this.initCallPtr) { + return arkts.factory.updateCallExpression( + node, + node.expression, + this.initCallTypeArguments ?? node.typeArguments, + this.initCallArgs + ); + } + return this.visitEachChild(node); + } +} diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts index f4975507f..ab12e3245 100644 --- a/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts @@ -19,12 +19,27 @@ import { BuilderLambdaNames, isCustomComponentAnnotation } from '../utils'; import { DeclarationCollector } from '../../common/declaration-collector'; import { ARKUI_IMPORT_PREFIX_NAMES, BindableDecl, Dollars, StructDecoratorNames } from '../../common/predefines'; import { ImportCollector } from '../../common/import-collector'; +import { + collectTypeRecordFromParameter, + collectTypeRecordFromTypeParameterDeclaration, + ParameterRecord, + TypeParameterTypeRecord, +} from '../../collectors/utils/collect-types'; +import { hasMemoAnnotation } from '../../collectors/memo-collectors/utils'; +import { AstNodePointer } from 'common/safe-types'; export type BuilderLambdaDeclInfo = { + name: string; isFunctionCall: boolean; // isFunctionCall means it is from $_instantiate. params: readonly arkts.Expression[]; returnType: arkts.TypeNode | undefined; moduleName: string; + hasReceiver?: boolean; +}; + +export type BuilderLambdaStyleBodyInfo = { + lambdaBody: arkts.Identifier | arkts.CallExpression | undefined; + initCallPtr: AstNodePointer | undefined; }; export type BuilderLambdaAstNode = arkts.ScriptFunction | arkts.ETSParameterExpression | arkts.FunctionDeclaration; @@ -333,10 +348,12 @@ export function findBuilderLambdaDeclInfo(decl: arkts.AstNode | undefined): Buil return undefined; } if (arkts.isMethodDefinition(decl)) { + const name = decl.name.name; const params = decl.scriptFunction.params.map((p) => p.clone()); const returnType = decl.scriptFunction.returnTypeAnnotation?.clone(); const isFunctionCall = isBuilderLambdaFunctionCall(decl); - return { isFunctionCall, params, returnType, moduleName }; + const hasReceiver = decl.scriptFunction.hasReceiver; + return { name, isFunctionCall, params, returnType, moduleName, hasReceiver }; } return undefined; @@ -558,3 +575,138 @@ export function collectComponentAttributeImport(type: arkts.TypeNode | undefined ImportCollector.getInstance().collectImport(attributeName); } } + +/** + * check whether the last parameter is trailing lambda in components. + */ +export function checkIsTrailingLambdaInLastParam(params: readonly arkts.Expression[]): boolean { + if (params.length === 0) { + return false; + } + const lastParam = params.at(params.length - 1)! as arkts.ETSParameterExpression; + return hasMemoAnnotation(lastParam) && lastParam.identifier.name === BuilderLambdaNames.COMPONENT_PARAM_ORI; +} + +/** + * remove any parameters except possible last trailing lambda parameter in components. + */ +export function filterParamsExpectTrailingLambda( + params: readonly arkts.Expression[] +): readonly arkts.Expression[] { + if (checkIsTrailingLambdaInLastParam(params)) { + return [params.at(params.length - 1)!]; + } + return []; +} + +/** + * check whether interface is `XXXAttribute` that implies the component's attribute interface. + */ +export function isComponentAttributeInterface(node: arkts.AstNode): node is arkts.TSInterfaceDeclaration { + if (!ComponentAttributeCache.getInstance().isCollected()) { + return false; + } + if (!arkts.isTSInterfaceDeclaration(node) || !node.id) { + return false; + } + return ComponentAttributeCache.getInstance().attributeName === node.id.name; +} + +/** + * get set method name for components. + */ +export function getDeclaredSetAttribtueMethodName(componentName: string): string { + return `set${componentName}Options`; +} + +// CACHE +export interface ComponentRecord { + name: string; + attributeRecords: ParameterRecord[]; + typeParams?: TypeParameterTypeRecord[]; + hasRestParameter?: boolean; + hasReceiver?: boolean; +} + +export class ComponentAttributeCache { + private _cache: Map; + private _attributeName: string | undefined; + private _isCollected: boolean = false; + private static instance: ComponentAttributeCache; + + private constructor() { + this._cache = new Map(); + } + + static getInstance(): ComponentAttributeCache { + if (!this.instance) { + this.instance = new ComponentAttributeCache(); + } + return this.instance; + } + + private collectAttributeName(type: arkts.TypeNode | undefined): string | undefined { + if ( + !type || + !arkts.isETSTypeReference(type) || + !type.part || + !type.part.name || + !arkts.isIdentifier(type.part.name) + ) { + return; + } + this._attributeName = type.part.name.name; + } + + get attributeName(): string | undefined { + return this._attributeName; + } + + reset(): void { + this._cache.clear(); + this._attributeName = undefined; + this._isCollected = false; + } + + isCollected(): boolean { + return this._isCollected; + } + + collect(node: arkts.MethodDefinition): void { + this.collectAttributeName(node.scriptFunction.returnTypeAnnotation); + if (!this._attributeName) { + return; + } + const name: string = node.name.name; + const hasRestParameter = node.scriptFunction.hasRestParameter; + const hasReceiver = node.scriptFunction.hasReceiver; + const typeParams = collectTypeRecordFromTypeParameterDeclaration(node.scriptFunction.typeParams); + const params = node.scriptFunction.params as arkts.ETSParameterExpression[]; + const attributeRecords: ParameterRecord[] = []; + const hasLastTrailingLambda = checkIsTrailingLambdaInLastParam(params); + params.forEach((p, index) => { + if (index === params.length - 1 && hasLastTrailingLambda) { + return; + } + const record = collectTypeRecordFromParameter(p); + attributeRecords.push(record); + }); + const componentRecord: ComponentRecord = { + name, + attributeRecords, + typeParams, + hasRestParameter, + hasReceiver, + }; + this._cache.set(name, componentRecord); + this._isCollected = true; + } + + getComponentRecord(name: string): ComponentRecord | undefined { + return this._cache.get(name); + } + + getAllComponentRecords(): ComponentRecord[] { + return Array.from(this._cache.values()); + } +} diff --git a/arkui-plugins/ui-plugins/checked-transformer.ts b/arkui-plugins/ui-plugins/checked-transformer.ts index 0dbc8b445..80b686edb 100644 --- a/arkui-plugins/ui-plugins/checked-transformer.ts +++ b/arkui-plugins/ui-plugins/checked-transformer.ts @@ -19,7 +19,11 @@ import { factory as structFactory } from './struct-translators/factory'; import { factory as builderLambdaFactory } from './builder-lambda-translators/factory'; import { factory as entryFactory } from './entry-translators/factory'; import { AbstractVisitor } from '../common/abstract-visitor'; -import { isBuilderLambda, isBuilderLambdaMethodDecl } from './builder-lambda-translators/utils'; +import { + ComponentAttributeCache, + isBuilderLambda, + isBuilderLambdaMethodDecl, +} from './builder-lambda-translators/utils'; import { isEntryWrapperClass } from './entry-translators/utils'; import { ImportCollector } from '../common/import-collector'; import { DeclarationCollector } from '../common/declaration-collector'; @@ -33,7 +37,7 @@ import { LoaderJson, ResourceInfo, ScopeInfoCollection, - isForEachDecl + isForEachDecl, } from './struct-translators/utils'; import { collectCustomComponentScopeInfo, CustomComponentNames, isCustomComponentClass } from './utils'; import { findAndCollectMemoableNode } from '../collectors/memo-collectors/factory'; @@ -56,6 +60,7 @@ export class CheckedTransformer extends AbstractVisitor { super.reset(); this.scope = { customComponents: [] }; PropertyCache.getInstance().reset(); + ComponentAttributeCache.getInstance().reset(); ImportCollector.getInstance().reset(); DeclarationCollector.getInstance().reset(); LogCollector.getInstance().reset(); @@ -98,8 +103,12 @@ export class CheckedTransformer extends AbstractVisitor { if (arkts.isEtsScript(node)) { insertImportDeclaration(this.program); } - if (arkts.isClassDeclaration(node) && node.definition && node.definition.ident && - node.definition.ident.name === 'CustomDialogController') { + if ( + arkts.isClassDeclaration(node) && + node.definition && + node.definition.ident && + node.definition.ident.name === 'CustomDialogController' + ) { return transformDeclaration(node as arkts.ClassDeclaration); } return node; @@ -111,10 +120,7 @@ export class CheckedTransformer extends AbstractVisitor { const lambda = builderLambdaFactory.transformBuilderLambda(beforeChildren); return this.visitEachChild(lambda); } else if (arkts.isMethodDefinition(beforeChildren) && isBuilderLambdaMethodDecl(beforeChildren)) { - const lambda = builderLambdaFactory.transformBuilderLambdaMethodDecl( - beforeChildren, - this.externalSourceName - ); + const lambda = builderLambdaFactory.transformBuilderLambdaMethodDecl(beforeChildren); return this.visitEachChild(lambda); } const node = this.visitEachChild(beforeChildren); diff --git a/arkui-plugins/ui-plugins/struct-translators/factory.ts b/arkui-plugins/ui-plugins/struct-translators/factory.ts index c450bf11e..9cad2c674 100644 --- a/arkui-plugins/ui-plugins/struct-translators/factory.ts +++ b/arkui-plugins/ui-plugins/struct-translators/factory.ts @@ -25,6 +25,7 @@ import { } from '../utils'; import { factory as uiFactory } from '../ui-factory'; import { factory as propertyFactory } from '../property-translators/factory'; +import { factory as builderLambdaFactory } from '../builder-lambda-translators/factory'; import { collect, filterDefined } from '../../common/arkts-utils'; import { classifyObservedTrack, @@ -49,6 +50,7 @@ import { isForEachCall, } from './utils'; import { collectStateManagementTypeImport, hasDecorator, PropertyCache } from '../property-translators/utils'; +import { ComponentAttributeCache, isComponentAttributeInterface } from '../builder-lambda-translators/utils'; import { ProjectConfig } from '../../common/plugin-context'; import { ImportCollector } from '../../common/import-collector'; import { @@ -252,13 +254,18 @@ export class factory { } /** - * add headers for animation & @AnimatableExtend in CommonMethod + * add following declared methods in `CommonMethod` interface: + * - `animationStart` and `animationStop` for `Animation` component; + * - `__createOrSetAnimatableProperty` for `@AnimatableExtend` function with receiver; + * - `applyAttributesFinish` for component's style set options method. */ static modifyExternalComponentCommon(node: arkts.TSInterfaceDeclaration): arkts.TSInterfaceDeclaration { const animationStart = factory.createAnimationMethod(AnimationNames.ANIMATION_START); const animationStop = factory.createAnimationMethod(AnimationNames.ANIMATION_STOP); const createOrSetAniProperty = factory.createOrSetAniProperty(); + const applyAttributesFinish = builderLambdaFactory.createDeclaredApplyAttributesFinish(); const updatedBody = arkts.factory.updateInterfaceBody(node.body!, [ + applyAttributesFinish, animationStart, animationStop, createOrSetAniProperty, @@ -604,13 +611,17 @@ export class factory { if (!node.id || !node.body) { return node; } - if (externalSourceName === ARKUI_COMPONENT_COMMON_SOURCE_NAME && node.id.name === 'CommonMethod') { - return factory.modifyExternalComponentCommon(node); + const newNode = factory.tranformInterfaceBuildMember(node); + if (externalSourceName === ARKUI_COMPONENT_COMMON_SOURCE_NAME && newNode.id!.name === 'CommonMethod') { + return factory.modifyExternalComponentCommon(newNode); } - if (isCustomComponentInterface(node)) { - return factory.tranformCustomComponentInterfaceMembers(node); + if (isCustomComponentInterface(newNode)) { + return factory.tranformCustomComponentInterfaceMembers(newNode); } - return factory.tranformInterfaceBuildMember(node); + if (isComponentAttributeInterface(newNode)) { + return builderLambdaFactory.addDeclaredSetMethodsInAttributeInterface(newNode); + } + return newNode; } static tranformInterfaceBuildMember(node: arkts.TSInterfaceDeclaration): arkts.TSInterfaceDeclaration { diff --git a/arkui-plugins/ui-plugins/type-translators/factory.ts b/arkui-plugins/ui-plugins/type-translators/factory.ts new file mode 100644 index 000000000..14e265042 --- /dev/null +++ b/arkui-plugins/ui-plugins/type-translators/factory.ts @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as arkts from '@koalaui/libarkts'; +import { + ArrayTypeRecord, + FunctionTypeRecord, + NullTypeRecord, + PrimitiveTypeRecord, + ThisTypeRecord, + TypeRecord, + TypeRecordTypes, + TypeReferenceTypeRecord, + UndefinedTypeRecord, + UnionTypeRecord, + ParameterRecord, + TypeParameterTypeRecord, +} from '../../collectors/utils/collect-types'; + +export class factory { + /** + * generate type node from `TypeRecord` + */ + static createTypeNodeFromRecord(record: TypeRecord): arkts.TypeNode { + const type = record?.type; + switch (type) { + case TypeRecordTypes.ARRAY: + return factory.createArrayTypeFromRecord(record); + case TypeRecordTypes.FUNCTION: + return factory.createFunctionTypeFromRecord(record); + case TypeRecordTypes.NULL: + return factory.createNullTypeFromRecord(record); + case TypeRecordTypes.UNDEFINED: + return factory.createUndefinedTypeFromRecord(record); + case TypeRecordTypes.THIS: + return factory.createThisTypeFromRecord(record); + case TypeRecordTypes.UNION: + return factory.createUnionTypeFromRecord(record); + case TypeRecordTypes.TYPE_REFERENCE: + return factory.createTypeReferenceFromRecord(record); + case TypeRecordTypes.PRIMITIVE: + return factory.createPrimitiveTypeFromRecord(record); + default: + throw new Error(`Unknown type node's type: ${type}`); + } + } + + /** + * generate `arkts.ETSPrimitiveType` node from `PrimitiveTypeRecord` + */ + static createPrimitiveTypeFromRecord(record: PrimitiveTypeRecord): arkts.ETSPrimitiveType { + const typeName = record?.typeName; + switch (typeName) { + case 'boolean': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_BOOLEAN); + case 'byte': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_BYTE); + case 'char': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_CHAR); + case 'double': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_DOUBLE); + case 'float': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_FLOAT); + case 'int': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_INT); + case 'long': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_LONG); + case 'short': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_SHORT); + case 'void': + return arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID); + default: + throw new Error(`Cannot create primitive type because of name: ${typeName}`); + } + } + + /** + * generate `arkts.ETSParameterExpression` node from `ParameterRecord` + */ + static createParameterFromRecord(record: ParameterRecord): arkts.ETSParameterExpression { + const name = record.name; + const annotations = record.annotations.map((a) => a.clone()); + const isOptional = record.isOptional; + const typeAnnotation = factory.createTypeNodeFromRecord(record.typeRecord); + const parameter = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(name, typeAnnotation), + undefined + ); + parameter.annotations = annotations; + if (isOptional) { + parameter.setOptional(true); + } + return parameter; + } + + /** + * generate `arkts.TSTypeParameter` node from `TypeParameterTypeRecord` + */ + static createTypeParameterFromRecord(record: TypeParameterTypeRecord): arkts.TSTypeParameter { + const annotations = record.annotations.map((a) => a.clone()); + const typeName = record.typeName ? arkts.factory.createIdentifier(record.typeName) : undefined; + const defaultType = record.defaultType ? factory.createTypeNodeFromRecord(record.defaultType) : undefined; + const constraint = record.constraint ? factory.createTypeNodeFromRecord(record.constraint) : undefined; + const typeParameter = arkts.factory.createTypeParameter(typeName, constraint, defaultType); + typeParameter.setAnnotations(annotations); + return typeParameter; + } + + /** + * generate `arkts.TSArrayType` node from `ArrayTypeRecord` + */ + static createArrayTypeFromRecord(record: ArrayTypeRecord): arkts.TSArrayType { + const elementType = record.elementType ? factory.createTypeNodeFromRecord(record.elementType) : undefined; + return arkts.factory.createTSArrayType(elementType); + } + + /** + * generate `arkts.ETSNullType` node from `NullTypeRecord` + */ + static createNullTypeFromRecord(record: NullTypeRecord): arkts.ETSNullType { + return arkts.factory.createETSNullType(); + } + + /** + * generate `arkts.ETSUndefinedType` node from `UndefinedTypeRecord` + */ + static createUndefinedTypeFromRecord(record: UndefinedTypeRecord): arkts.ETSUndefinedType { + return arkts.factory.createETSUndefinedType(); + } + + /** + * generate `arkts.TSThisType` node from `ThisTypeRecord` + */ + static createThisTypeFromRecord(record: ThisTypeRecord): arkts.TSThisType { + return arkts.factory.createTSThisType(); + } + + /** + * generate `arkts.ETSFunctionType` node from `FunctionTypeRecord` + */ + static createFunctionTypeFromRecord(record: FunctionTypeRecord): arkts.ETSFunctionType { + const annotations = record.annotations.map((a) => a.clone()); + const returnType = factory.createTypeNodeFromRecord(record.returnType); + const params = record.params.map((p) => factory.createParameterFromRecord(p)); + const typeParams = record.typeParams?.map((p) => factory.createTypeParameterFromRecord(p)); + const funcType = arkts.factory.createFunctionType( + arkts.factory.createFunctionSignature( + typeParams ? arkts.factory.createTypeParameterDeclaration(typeParams, typeParams.length) : undefined, + params, + returnType, + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + funcType.setAnnotations(annotations); + return funcType; + } + + /** + * generate `arkts.ETSUnionType` node from `UnionTypeRecord` + */ + static createUnionTypeFromRecord(record: UnionTypeRecord): arkts.ETSUnionType { + const types = record.types.map((t) => factory.createTypeNodeFromRecord(t)); + return arkts.factory.createUnionType(types); + } + + /** + * @internal + */ + static createTypeNameForTypeReferencePart(name: string | string[]): arkts.Expression { + if (!Array.isArray(name)) { + return arkts.factory.createIdentifier(name); + } + const names = name.map((n) => arkts.factory.createIdentifier(n)); + if (names.length === 1) { + return names.at(0)!; + } + const leftName = names.shift(); + const rightName = names.shift(); + let nameNode: arkts.TSQualifiedName = arkts.factory.createTSQualifiedName(leftName, rightName); + while (names.length > 0) { + const currName = names.shift(); + nameNode = arkts.factory.updateTSQualifiedName(nameNode, nameNode, currName); + } + return nameNode; + } + + /** + * generate `arkts.ETSTypeReference` node from `TypeReferenceTypeRecord` + */ + static createTypeReferenceFromRecord(record: TypeReferenceTypeRecord): arkts.ETSTypeReference { + const name = record.typeName; + const annotations = record.annotations; + const typeParams = record.typeParams?.map((p) => factory.createTypeNodeFromRecord(p)); + const typeRef = arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + factory.createTypeNameForTypeReferencePart(name), + typeParams ? arkts.factory.createTSTypeParameterInstantiation(typeParams) : undefined + ) + ); + typeRef.setAnnotations(annotations); + return typeRef; + } +} diff --git a/arkui-plugins/ui-plugins/utils.ts b/arkui-plugins/ui-plugins/utils.ts index 562c74f4e..cb6ae080e 100644 --- a/arkui-plugins/ui-plugins/utils.ts +++ b/arkui-plugins/ui-plugins/utils.ts @@ -43,7 +43,9 @@ export enum BuilderLambdaNames { TRANSFORM_METHOD_NAME = '_instantiateImpl', STYLE_PARAM_NAME = 'style', STYLE_ARROW_PARAM_NAME = 'instance', - CONTENT_PARAM_NAME = 'content' + CONTENT_PARAM_NAME = 'content', + COMPONENT_PARAM_ORI = 'content_', + APPLY_ATTRIBUTES_FINISH_METHOD = 'applyAttributesFinish' } // IMPORT diff --git a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts index c780fdbf9..cabad86df 100644 --- a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts +++ b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts @@ -81,6 +81,10 @@ import { ForUpdateStatement, ForInStatement, ForOfStatement, + TSArrayType, + ETSNullType, + TSThisType, + TSQualifiedName, } from '../../generated'; import { Es2pandaModifierFlags } from '../../generated/Es2pandaEnums'; import { classPropertySetOptional, hasModifierFlag } from '../utilities/public'; @@ -142,6 +146,10 @@ import { updateTSClassImplements } from '../node-utilities/TSClassImplements'; import { updateForUpdateStatement } from '../node-utilities/ForUpdateStatement'; import { updateForInStatement } from '../node-utilities/ForInStatement'; import { updateForOfStatement } from '../node-utilities/ForOfStatement'; +import { updateTSArrayType } from '../node-utilities/TSArrayType'; +import { updateETSNullType } from '../node-utilities/ETSNullType'; +import { updateTSThisType } from '../node-utilities/TSThisType'; +import { updateTSQualifiedName } from '../node-utilities/TSQualifiedName'; export const factory = { get createIdentifier(): (...args: Parameters) => Identifier { @@ -601,6 +609,30 @@ export const factory = { get updateForOfStatement(): (...args: Parameters) => ForOfStatement { return updateForOfStatement; }, + get createTSArrayType(): (...args: Parameters) => TSArrayType { + return TSArrayType.createTSArrayType; + }, + get updateTSArrayType(): (...args: Parameters) => TSArrayType { + return updateTSArrayType; + }, + get createETSNullType(): (...args: Parameters) => ETSNullType { + return ETSNullType.createETSNullType; + }, + get updateETSNullType(): (...args: Parameters) => ETSNullType { + return updateETSNullType; + }, + get createTSThisType(): (...args: Parameters) => TSThisType { + return TSThisType.createTSThisType; + }, + get updateTSThisType(): (...args: Parameters) => TSThisType { + return updateTSThisType; + }, + get createTSQualifiedName(): (...args: Parameters) => TSQualifiedName { + return TSQualifiedName.createTSQualifiedName; + }, + get updateTSQualifiedName(): (...args: Parameters) => TSQualifiedName { + return updateTSQualifiedName; + }, /** @deprecated */ createTypeParameter1_(name: Identifier, constraint?: TypeNode, defaultType?: TypeNode) { return TSTypeParameter.createTSTypeParameter(Identifier.create1Identifier(name.name), constraint, defaultType); diff --git a/koala-wrapper/src/arkts-api/index.ts b/koala-wrapper/src/arkts-api/index.ts index eef8304a5..e76f056e4 100644 --- a/koala-wrapper/src/arkts-api/index.ts +++ b/koala-wrapper/src/arkts-api/index.ts @@ -63,6 +63,7 @@ export * from '../generated/peers/TSArrayType'; export * from '../generated/peers/ArrayExpression'; export * from '../generated/peers/TryStatement'; export * from '../generated/peers/ETSNullType'; +export * from '../generated/peers/TSQualifiedName'; export * from './types'; export * from './utilities/private'; diff --git a/koala-wrapper/src/arkts-api/node-utilities/ETSNullType.ts b/koala-wrapper/src/arkts-api/node-utilities/ETSNullType.ts new file mode 100644 index 000000000..7e1b10940 --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/ETSNullType.ts @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { ETSNullType } from '../../generated'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateETSNullType( + original: ETSNullType +): ETSNullType { + /* TODO: no getter provided yet */ + + const update = updateThenAttach(ETSNullType.updateETSNullType, attachModifiers); + return update(original); +} diff --git a/koala-wrapper/src/arkts-api/node-utilities/TSArrayType.ts b/koala-wrapper/src/arkts-api/node-utilities/TSArrayType.ts new file mode 100644 index 000000000..fcbfdb5da --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/TSArrayType.ts @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { TSArrayType, TypeNode } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateTSArrayType( + original: TSArrayType, + elementType?: TypeNode +): TSArrayType { + if ( + isSameNativeObject(elementType, original.elementType) + ) { + return original; + } + + const update = updateThenAttach(TSArrayType.updateTSArrayType, attachModifiers); + return update(original, elementType); +} diff --git a/koala-wrapper/src/arkts-api/node-utilities/TSQualifiedName.ts b/koala-wrapper/src/arkts-api/node-utilities/TSQualifiedName.ts new file mode 100644 index 000000000..655c3239c --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/TSQualifiedName.ts @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { Expression, Identifier, TSQualifiedName } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateTSQualifiedName( + original: TSQualifiedName, + left?: Expression, + right?: Identifier +): TSQualifiedName { + if (isSameNativeObject(left, original.left) && isSameNativeObject(right, original.right)) { + return original; + } + + const update = updateThenAttach(TSQualifiedName.updateTSQualifiedName, attachModifiers); + return update(original); +} diff --git a/koala-wrapper/src/arkts-api/node-utilities/TSThisType.ts b/koala-wrapper/src/arkts-api/node-utilities/TSThisType.ts new file mode 100644 index 000000000..77b1c0e60 --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/TSThisType.ts @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { TSThisType } from '../../generated'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateTSThisType( + original: TSThisType +): TSThisType { + /* TODO: no getter provided yet */ + + const update = updateThenAttach(TSThisType.updateTSThisType, attachModifiers); + return update(original); +} diff --git a/koala-wrapper/src/arkts-api/types.ts b/koala-wrapper/src/arkts-api/types.ts index d73f539d0..9241a12d1 100644 --- a/koala-wrapper/src/arkts-api/types.ts +++ b/koala-wrapper/src/arkts-api/types.ts @@ -572,7 +572,7 @@ export class ETSParameterExpression extends Expression { global.generatedEs2panda._ETSParameterExpressionSetTypeAnnotation(global.context, this.peer, t.peer); } - get optional(): Boolean { + get optional(): boolean { return global.generatedEs2panda._ETSParameterExpressionIsOptionalConst(global.context, this.peer); } -- Gitee From ebc69c260074a31256246df2084789193ecc600f Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Thu, 3 Jul 2025 09:47:51 +0800 Subject: [PATCH 2/6] update ut Signed-off-by: VictorS67 Change-Id: If53cf0e3ab50a30bbc738356c1d34f7da0afd8c6 --- .../builder-lambda/simple-component.test.ts | 21 ++++++++++++++-- .../style-with-receiver.test.ts | 15 +++++++---- .../ut/ui-plugins/component/for-each.test.ts | 24 +++++++++++++++--- .../decorators/builder/global-builder.test.ts | 25 ++++++++++++++++--- .../decorators/builder/local-builder.test.ts | 13 ++++++---- .../resource/resource-in-property.test.ts | 23 ++++++++++++++--- .../wrap-builder/init-with-builder.test.ts | 10 +++++--- .../wrap-builder/wrap-builder-in-ui.test.ts | 15 +++++++---- 8 files changed, 114 insertions(+), 32 deletions(-) diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts index e8e1ace16..770835667 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts @@ -32,13 +32,17 @@ const pluginTester = new PluginTester('test builder-lambda simple component', bu function testBuilderLambdaTransformer(this: PluginTestContext): void { const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { memo as memo } from \"@ohos.arkui.stateManagement\"; import { Column as Column, ColumnAttribute as ColumnAttribute } from \"arkui.component.column\"; function main() {} class MyStateSample { @memo() public build() { - Column(undefined, undefined, @memo() (() => {})); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => {})); } public constructor() {} } @@ -49,6 +53,7 @@ class MyStateSample { function testMemoTransformer(this: PluginTestContext): void { const expectedScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"arkui.stateManagement.runtime\"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { memo as memo } from \"@ohos.arkui.stateManagement\"; import { Column as Column, ColumnAttribute as ColumnAttribute } from \"arkui.component.column\"; @@ -60,7 +65,19 @@ class MyStateSample { __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (65509320)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (147296800)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts index 8e2c2dd05..da840d684 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts @@ -39,6 +39,8 @@ const parsedTransform: Plugins = { const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; @@ -76,15 +78,18 @@ function main() {} public __updateStruct(initializers: (__Options_MM | undefined)): void {} @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Text(@memo() ((instance: TextAttribute): void => { - style22(cardStyle(instance.height(200).fontColor("#000000"), 600, "#eeeeee").fontSize(60).fontWeight(400)).width(900); + style22(cardStyle(instance.setTextOptions("hello world", undefined).height(200).fontColor("#000000"), 600, "#eeeeee").fontSize(60).fontWeight(400)).width(900).applyAttributesFinish(); return; - }), "hello world", undefined, undefined); + }), undefined); Text(@memo() ((instance: TextAttribute): void => { - cardStyle(instance, 600, "#eeeeee"); + cardStyle(instance.setTextOptions("hello world", undefined), 600, "#eeeeee").applyAttributesFinish(); return; - }), "hello world", undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts b/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts index fc931a331..2f801522f 100644 --- a/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts @@ -38,6 +38,10 @@ const parsedTransform: Plugins = { }; const expectedScript: string = ` +import { TextAttribute as TextAttribute } from "arkui.component.text"; + +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -98,21 +102,33 @@ class AB { } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { ForEach(((): Array => { return this.arr; }), ((item: string) => { - Text(undefined, item, undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(item, undefined).applyAttributesFinish(); + return; + }), undefined); })); ForEach(((): Array => { return this.getArray(); }), ((item: Person) => { - Text(undefined, item.name, undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(item.name, undefined).applyAttributesFinish(); + return; + }), undefined); })); ForEach(((): Array => { return new AB().bar; }), ((item: string) => { - Text(undefined, item, undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(item, undefined).applyAttributesFinish(); + return; + }), undefined); })); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts index 3ecead486..38178f77e 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts @@ -37,8 +37,12 @@ const parsedTransform: Plugins = { const expectedScript: string = ` +import { RowAttribute as RowAttribute } from "arkui.component.row"; + import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -51,12 +55,22 @@ function main() {} @memo() function showTextBuilder() { - Text(undefined, "Hello World", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); + return; + }), undefined); + } } @memo() function overBuilder(params: Tmp) { - Row(undefined, undefined, @memo() (() => { - Text(undefined, (("UseStateVarByReference: ") + (params.paramA1)), undefined, undefined); + Row(@memo() ((instance: RowAttribute): void => { + instance.setRowOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions((("UseStateVarByReference: ") + (params.paramA1)), undefined).applyAttributesFinish(); + return; + }), undefined); })); } @@ -74,7 +88,10 @@ class Tmp { public __updateStruct(initializers: (__Options_BuilderDemo | undefined)): void {} @memo() public build() { - Row(undefined, undefined, @memo() (() => { + Row(@memo() ((instance: RowAttribute): void => { + instance.setRowOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { showTextBuilder(); overBuilder({ paramA1: "Hello", diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts index 318d1ee71..218010411 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts @@ -60,20 +60,23 @@ function main() {} @memo() public showTextBuilder() { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(30); + instance.setTextOptions("Hello World", undefined).fontSize(30).applyAttributesFinish(); return; - }), "Hello World", undefined, undefined); + }), undefined); } @memo() public showTextValueBuilder(param: string) { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(30); + instance.setTextOptions(param, undefined).fontSize(30).applyAttributesFinish(); return; - }), param, undefined, undefined); + }), undefined); } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { this.showTextBuilder(); this.showTextValueBuilder("Hello @Builder"); })); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts index 89b0c4750..e1c06c5a9 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts @@ -38,7 +38,10 @@ const parsedTransform: Plugins = { }; const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ImageAttribute as ImageAttribute } from "arkui.component.image"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { _rawfile as _rawfile } from "arkui.component.resources"; import { _r as _r } from "arkui.component.resources"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -75,10 +78,22 @@ i = _r(16777216, 10003, "com.example.mock", "entry"); } @memo() public build() { - Column(undefined, undefined, @memo() (() => { - Text(undefined, this.str, undefined, undefined); - Text(undefined, i, undefined, undefined); - Image(undefined, this.icon, undefined, undefined); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(this.str, undefined).applyAttributesFinish(); + return; + }), undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(i, undefined).applyAttributesFinish(); + return; + }), undefined); + Image(@memo() ((instance: ImageAttribute): void => { + instance.setImageOptions(this.icon, undefined).applyAttributesFinish(); + return; + }), undefined); })); } private constructor() {} diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts index b88e465bd..749110403 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts @@ -38,6 +38,7 @@ const parsedTransform: Plugins = { }; const expectedUIScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -52,9 +53,9 @@ function main() {} globalBuilder = wrapBuilder(myBuilder); @memo() function myBuilder(value: string, size: number) { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(size); + instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; - }), value, undefined, undefined); + }), undefined); } @@ -66,7 +67,10 @@ globalBuilder = wrapBuilder(myBuilder); public __updateStruct(initializers: (__Options_ImportStruct | undefined)): void {} @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { globalBuilder.builder("hello", 50); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts index 42bb161d1..b614702b1 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts @@ -38,6 +38,8 @@ const parsedTransform: Plugins = { }; const expectedUIScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; @@ -57,16 +59,16 @@ function main() {} @memo() function myBuilder(value: string, size: number) { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(size); + instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; - }), value, undefined, undefined); + }), undefined); } @memo() function yourBuilder(value: string, size: number) { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(size); + instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; - }), value, undefined, undefined); + }), undefined); } @@ -86,7 +88,10 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { this.testBuilder(); })); } -- Gitee From 697a19c7e620c1aef92dbedae88abc0680641757 Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Fri, 4 Jul 2025 14:53:56 +0800 Subject: [PATCH 3/6] update ut part2 Signed-off-by: VictorS67 Change-Id: Ie4ba03783e08d0a15a4734236fbb54f1671f4d59 --- .../animation/animatable-extend-basic.test.ts | 12 ++- .../animation/animation-basic.test.ts | 12 ++- .../custom-component-call.test.ts | 23 +++++- .../builder-param-passing.test.ts | 63 ++++++++++++-- .../optional-builder-param.test.ts | 82 +++++++++++++++++-- .../decorators/builder/global-builder.test.ts | 7 +- .../decorators/builder/local-builder.test.ts | 1 + .../link/link-to-link-prop-state.test.ts | 27 ++++-- .../decorators/link/state-to-link.test.ts | 64 +++++++++------ .../objectlink/objectlink-observed.test.ts | 30 ++++--- .../decorators/prop/state-to-prop.test.ts | 49 +++++++---- .../resource/resource-in-build.test.ts | 81 ++++++++++++------ .../reusable/reusable-complex.test.ts | 22 ++--- .../decorators/state/state-to-state.test.ts | 13 ++- .../decorators/watch/watch-basic.test.ts | 7 +- .../double-dollar-griditem.test.ts | 40 ++++++--- .../ui-plugins/imports/import-struct.test.ts | 7 +- .../ut/ui-plugins/imports/kit-import.test.ts | 15 ++-- 18 files changed, 411 insertions(+), 144 deletions(-) diff --git a/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts index d0f5ac29d..b680bfe9f 100644 --- a/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts @@ -39,6 +39,7 @@ const animatableExtendTransform: Plugins = { const pluginTester = new PluginTester('test basic animatableExtend transform', buildConfig); const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; @@ -76,9 +77,12 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public __updateStruct(initializers: (__Options_AnimatablePropertyExample | undefined)): void {} @memo() public build() { - Column(undefined, undefined, (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), (() => { Text(@memo() ((instance: TextAttribute): void => { - instance.animationStart({ + instance.setTextOptions("AnimatableProperty", undefined).animationStart({ duration: 2000, curve: Curve.Ease, }).backgroundColor(Color.Red).animationStop({ @@ -90,9 +94,9 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ }).fontSize(20).animationStop({ duration: 2000, curve: Curve.Ease, - }).width("100%"); + }).width("100%").applyAttributesFinish(); return; - }), "AnimatableProperty", undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts index ac52cd1e5..94ee904c0 100644 --- a/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts @@ -38,6 +38,7 @@ const animationTransform: Plugins = { const pluginTester = new PluginTester('test basic animation transform', buildConfig); const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; @@ -75,9 +76,12 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public __updateStruct(initializers: (__Options_AnimatablePropertyExample | undefined)): void {} @memo() public build() { - Column(undefined, undefined, (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), (() => { Text(@memo() ((instance: TextAttribute): void => { - instance.animationStart({ + instance.setTextOptions("AnimatableProperty", undefined).animationStart({ duration: 2000, curve: Curve.Ease, }).backgroundColor(Color.Red).animationStop({ @@ -89,9 +93,9 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ }).fontSize(20).animationStop({ duration: 2000, curve: Curve.Ease, - }).width("100%"); + }).width("100%").applyAttributesFinish(); return; - }), "AnimatableProperty", undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts index 2f3702d00..62ef61a2b 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts @@ -100,6 +100,9 @@ function testParedTransformer(this: PluginTestContext): void { } const expectedBuilderLambdaScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { memo as memo } from "arkui.stateManagement.runtime"; @@ -147,18 +150,30 @@ function main() {} public __updateStruct(initializers: (__Options_CustomContainerUser | undefined)): void {} @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { CustomContainer._instantiateImpl(undefined, (() => { return new CustomContainer(); }), undefined, undefined, @memo() (() => { - Column(undefined, undefined, @memo() (() => { - Text(undefined, "hello", undefined, undefined); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("hello", undefined).applyAttributesFinish(); + return; + }), undefined); })); })); CustomContainer._instantiateImpl(undefined, (() => { return new CustomContainer(); }), {}, undefined, @memo() (() => { - Column(undefined, undefined, @memo() (() => {})); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => {})); })); CustomContainer._instantiateImpl(undefined, (() => { return new CustomContainer(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts index c95268bf1..9884aa2f6 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts @@ -38,6 +38,10 @@ const parsedTransform: Plugins = { }; const expectedAfterUIScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -84,11 +88,17 @@ function main() {} public __updateStruct(initializers: (__Options_Parent | undefined)): void {} @memo() public componentBuilder() { - Text(undefined, "Parent builder", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + return; + }), undefined); } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Child._instantiateImpl(undefined, (() => { return new Child(); }), { @@ -104,7 +114,10 @@ function main() {} Child._instantiateImpl(undefined, (() => { return new Child(); }), undefined, undefined, @memo() (() => { - Text(undefined, "Parent builder", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + return; + }), undefined); })); })); } @@ -127,6 +140,8 @@ function main() {} const expectedAfterMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -193,7 +208,19 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (137225318)), undefined, "Parent builder", undefined, undefined); + Text(__memo_context, ((__memo_id) + (137225318)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), undefined); { __memo_scope.recache(); return; @@ -206,7 +233,19 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (136716185)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (136716185)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (54078781)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; @@ -241,7 +280,19 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (223657391)), undefined, "Parent builder", undefined, undefined); + Text(__memo_context, ((__memo_id) + (223657391)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), undefined); { __memo_scope.recache(); return; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts index c16283a4e..286ca356a 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts @@ -38,7 +38,10 @@ const parsedTransform: Plugins = { }; const expectedUIScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { RowAttribute as RowAttribute } from "arkui.component.row"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; @@ -47,7 +50,10 @@ import { Component as Component, Entry as Entry, Builder as Builder, BuilderPara function main() {} @memo() function showTextBuilder() { - Text(undefined, "Hello World", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); + return; + }), undefined); } @Component() final struct Child extends CustomComponent { @@ -81,7 +87,10 @@ function main() {} } @memo() public build() { - Row(undefined, undefined, @memo() (() => { + Row(@memo() ((instance: RowAttribute): void => { + instance.setRowOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { if (this.customBuilderParam2) { (this.customBuilderParam2 as (()=> void))(); } @@ -102,11 +111,17 @@ function main() {} public __updateStruct(initializers: (__Options_Parent | undefined)): void {} @memo() public componentBuilder() { - Text(undefined, "Parent builder", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + return; + }), undefined); } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Child._instantiateImpl(undefined, (() => { return new Child(); }), { @@ -138,7 +153,10 @@ function main() {} const expectedMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { RowAttribute as RowAttribute } from "arkui.component.row"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; @@ -152,7 +170,19 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (47330804)), undefined, "Hello World", undefined, undefined); + Text(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), undefined); { __memo_scope.recache(); return; @@ -195,7 +225,19 @@ function main() {} __memo_scope.cached; return; } - Row(__memo_context, ((__memo_id) + (46726221)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Row(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: RowAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setRowOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (213104625)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; @@ -234,7 +276,19 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (218979098)), undefined, "Parent builder", undefined, undefined); + Text(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), undefined); { __memo_scope.recache(); return; @@ -247,7 +301,19 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (78055758)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (78055758)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + instance.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (136716185)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts index 38178f77e..903569d5a 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts @@ -56,10 +56,9 @@ function main() {} @memo() function showTextBuilder() { Text(@memo() ((instance: TextAttribute): void => { - instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); - return; - }), undefined); - } + instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); + return; + }), undefined); } @memo() function overBuilder(params: Tmp) { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts index 218010411..e299d9ac4 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts @@ -36,6 +36,7 @@ const parsedTransform: Plugins = { }; const expectedScript: string = ` +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts index a507ebd52..9dd321279 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts @@ -48,8 +48,12 @@ import { LinkSourceType as LinkSourceType } from "arkui.stateManagement.decorato import { ILinkDecoratedVariable as ILinkDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextInputAttribute as TextInputAttribute } from "arkui.component.textInput"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -83,10 +87,16 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { - TextInput(undefined, { - text: this.text1, - }, undefined); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + TextInput(@memo() ((instance: TextInputAttribute): void => { + instance.setTextInputOptions({ + text: this.text1, + }).applyAttributesFinish(); + return; + }), undefined); Child._instantiateImpl(undefined, (() => { return new Child(); }), { @@ -167,9 +177,12 @@ function main() {} } @memo() public build() { - TextInput(undefined, { - text: this.childText, - }, undefined); + TextInput(@memo() ((instance: TextInputAttribute): void => { + instance.setTextInputOptions({ + text: this.childText, + }).applyAttributesFinish(); + return; + }), undefined); } private constructor() {} diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts index 111874d8c..3f3722d66 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts @@ -46,6 +46,10 @@ import { LinkSourceType as LinkSourceType } from "arkui.stateManagement.decorato import { ILinkDecoratedVariable as ILinkDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + +import { DatePickerAttribute as DatePickerAttribute } from "arkui.component.datePicker"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; @@ -97,24 +101,30 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("child increase the year by 1", undefined).onClick(((e: ClickEvent) => { this.selectedDate.setFullYear(((this.selectedDate.getFullYear()) + (1))); - })); + })).applyAttributesFinish(); return; - }), "child increase the year by 1", undefined, undefined); + }), undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.margin(10).onClick(((e: ClickEvent) => { + instance.setButtonOptions("child update the new date", undefined).margin(10).onClick(((e: ClickEvent) => { this.selectedDate = new Date("2023-09-09"); - })); + })).applyAttributesFinish(); return; - }), "child update the new date", undefined, undefined); - DatePicker(undefined, { - start: new Date("1970-1-1"), - end: new Date("2100-1-1"), - selected: this.selectedDate, - }, undefined); + }), undefined); + DatePicker(@memo() ((instance: DatePickerAttribute): void => { + instance.setDatePickerOptions({ + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.selectedDate, + }).applyAttributesFinish(); + return; + }), undefined); })); } @@ -141,24 +151,30 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Button(@memo() ((instance: ButtonAttribute): void => { - instance.margin(10).onClick(((e: ClickEvent) => { + instance.setButtonOptions("parent increase the month by 1", undefined).margin(10).onClick(((e: ClickEvent) => { this.parentSelectedDate.setMonth(((this.parentSelectedDate.getMonth()) + (1))); - })); + })).applyAttributesFinish(); return; - }), "parent increase the month by 1", undefined, undefined); + }), undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.margin(10).onClick(((e: ClickEvent) => { + instance.setButtonOptions("parent update the new date", undefined).margin(10).onClick(((e: ClickEvent) => { this.parentSelectedDate = new Date("2023-07-07"); - })); + })).applyAttributesFinish(); + return; + }), undefined); + DatePicker(@memo() ((instance: DatePickerAttribute): void => { + instance.setDatePickerOptions({ + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.parentSelectedDate, + }).applyAttributesFinish(); return; - }), "parent update the new date", undefined, undefined); - DatePicker(undefined, { - start: new Date("1970-1-1"), - end: new Date("2100-1-1"), - selected: this.parentSelectedDate, - }, undefined); + }), undefined); DateComponent._instantiateImpl(undefined, (() => { return new DateComponent(); }), { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts index aef8d5ccb..78e5bb8b0 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts @@ -43,6 +43,8 @@ import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateM import { IObjectLinkDecoratedVariable as IObjectLinkDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; @@ -204,13 +206,16 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("child increase the day by 1", undefined).onClick(((e: ClickEvent) => { this.data.setDate(((this.data.getDate()) + (1))); - })); + })).applyAttributesFinish(); return; - }), "child increase the day by 1", undefined, undefined); + }), undefined); })); } @@ -237,7 +242,10 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Child._instantiateImpl(undefined, (() => { return new Child(); }), { @@ -245,17 +253,17 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ data: this.newData.data, }, undefined, undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("parent update the new date", undefined).onClick(((e: ClickEvent) => { this.newData.data = new DateClass("2023-07-07"); - })); + })).applyAttributesFinish(); return; - }), "parent update the new date", undefined, undefined); + }), undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("ViewB: this.newData = new NewDate(new DateClass('2023-08-20'))", undefined).onClick(((e: ClickEvent) => { this.newData = new NewDate(new DateClass("2023-08-20")); - })); + })).applyAttributesFinish(); return; - }), "ViewB: this.newData = new NewDate(new DateClass('2023-08-20'))", undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts index 620bd9884..2b27545fb 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts @@ -44,10 +44,14 @@ import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement. import { IPropDecoratedVariable as IPropDecoratedVariable } from "arkui.stateManagement.decorator"; -import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -96,18 +100,27 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { if (((this.count) > (0))) { - Text(undefined, (((("You have") + (this.count))) + ("Nuggets left")), undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions((((("You have") + (this.count))) + ("Nuggets left")), undefined).applyAttributesFinish(); + return; + }), undefined); } else { - Text(undefined, "Game over!", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("Game over!", undefined).applyAttributesFinish(); + return; + }), undefined); } Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("Try again", undefined).onClick(((e: ClickEvent) => { this.count -= this.costOfOneAttempt; - })); + })).applyAttributesFinish(); return; - }), "Try again", undefined, undefined); + }), undefined); })); } @@ -134,20 +147,26 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { - Text(undefined, (((("Grant") + (this.countDownStartValue))) + ("nuggets to play.")), undefined, undefined); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions((((("Grant") + (this.countDownStartValue))) + ("nuggets to play.")), undefined).applyAttributesFinish(); + return; + }), undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("+1 - Nuggets in New Game", undefined).onClick(((e: ClickEvent) => { this.countDownStartValue += 1; - })); + })).applyAttributesFinish(); return; - }), "+1 - Nuggets in New Game", undefined, undefined); + }), undefined); Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("-1 - Nuggets in New Game", undefined).onClick(((e: ClickEvent) => { this.countDownStartValue -= 1; - })); + })).applyAttributesFinish(); return; - }), "-1 - Nuggets in New Game", undefined, undefined); + }), undefined); CountDownComponent._instantiateImpl(undefined, (() => { return new CountDownComponent(); }), { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts index 643f1955b..66a315c3d 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts @@ -40,12 +40,20 @@ const parsedTransform: Plugins = { const expectedScript: string = ` import { _rawfile as _rawfile } from "arkui.component.resources"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { ImageAnimatorAttribute as ImageAnimatorAttribute } from "arkui.component.imageAnimator"; -import { memo as memo } from "arkui.stateManagement.runtime"; +import { SelectAttribute as SelectAttribute } from "arkui.component.select"; + +import { TextInputAttribute as TextInputAttribute } from "arkui.component.textInput"; import { ImageAttribute as ImageAttribute } from "arkui.component.image"; +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { _r as _r } from "arkui.component.resources"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -109,40 +117,61 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { - Text(undefined, _r(16777216, 10003, "com.example.mock", "entry"), undefined, undefined); - Image(undefined, _rawfile(0, 30000, "com.example.mock", "entry", "app.mock.txt"), undefined, undefined); - TextInput(undefined, { - text: _r(16777220, 10003, "com.example.mock", "entry"), - }, undefined); - Text(undefined, _r(-1, -1, "com.example.mock", "entry", this.str1), undefined, undefined); - Text(undefined, _r(-1, -1, "com.example.mock", "entry", this.str2), undefined, undefined); - Select(undefined, new Array({ - value: "aaa", - icon: _r(16777223, 20000, "com.example.mock", "entry"), - }, { - value: "bbb", - icon: _r(16777223, 20000, "com.example.mock", "entry"), - }, { - value: "ccc", - icon: _r(16777223, 20000, "com.example.mock", "entry"), - }, { - value: "ddd", - icon: _r(16777223, 20000, "com.example.mock", "entry"), + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(_r(16777216, 10003, "com.example.mock", "entry"), undefined).applyAttributesFinish(); + return; + }), undefined); + Image(@memo() ((instance: ImageAttribute): void => { + instance.setImageOptions(_rawfile(0, 30000, "com.example.mock", "entry", "app.mock.txt"), undefined).applyAttributesFinish(); + return; + }), undefined); + TextInput(@memo() ((instance: TextInputAttribute): void => { + instance.setTextInputOptions({ + text: _r(16777220, 10003, "com.example.mock", "entry"), + }).applyAttributesFinish(); + return; + }), undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(_r(-1, -1, "com.example.mock", "entry", this.str1), undefined).applyAttributesFinish(); + return; + }), undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(_r(-1, -1, "com.example.mock", "entry", this.str2), undefined).applyAttributesFinish(); + return; + }), undefined); + Select(@memo() ((instance: SelectAttribute): void => { + instance.setSelectOptions(new Array({ + value: "aaa", + icon: _r(16777223, 20000, "com.example.mock", "entry"), + }, { + value: "bbb", + icon: _r(16777223, 20000, "com.example.mock", "entry"), + }, { + value: "ccc", + icon: _r(16777223, 20000, "com.example.mock", "entry"), + }, { + value: "ddd", + icon: _r(16777223, 20000, "com.example.mock", "entry"), + })).applyAttributesFinish(); + return; }), undefined); Image(@memo() ((instance: ImageAttribute): void => { - instance.margin(({ + instance.setImageOptions(_r(16777217, 20000, "com.example.mock", "entry"), undefined).margin(({ top: _r(16777222, 10002, "com.example.mock", "entry"), bottom: _r(16777222, 10002, "com.example.mock", "entry"), - } as Margin)); + } as Margin)).applyAttributesFinish(); return; - }), _r(16777217, 20000, "com.example.mock", "entry"), undefined, undefined); + }), undefined); ImageAnimator(@memo() ((instance: ImageAnimatorAttribute): void => { - instance.images([{ + instance.setImageAnimatorOptions().images([{ src: _r(16777217, 20000, "com.example.mock", "entry"), }, { src: _r(16777225, 20000, "com.example.mock", "entry"), - }]); + }]).applyAttributesFinish(); return; })); })); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts index e3f98d415..fe775048f 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts @@ -45,11 +45,11 @@ import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement. import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; -import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; -import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; import { NavInterface as NavInterface } from "arkui.UserView"; @@ -106,15 +106,15 @@ class Message { @memo() public build() { Column(@memo() ((instance: ColumnAttribute): void => { - instance.height("100%").width("100%"); + instance.setColumnOptions(undefined).height("100%").width("100%").applyAttributesFinish(); return; - }), undefined, @memo() (() => { + }), @memo() (() => { Button(@memo() ((instance: ButtonAttribute): void => { - instance.fontSize(30).fontWeight(FontWeight.Bold).onClick(((e: ClickEvent) => { + instance.setButtonOptions("Hello", undefined).fontSize(30).fontWeight(FontWeight.Bold).onClick(((e: ClickEvent) => { this.display = !(this.display); - })); + })).applyAttributesFinish(); return; - }), "Hello", undefined, undefined); + }), undefined); if (this.display) { Child._instantiateImpl(undefined, (() => { return new Child(); @@ -160,13 +160,13 @@ class Message { @memo() public build() { Column(@memo() ((instance: ColumnAttribute): void => { - instance.borderWidth(1).height(100); + instance.setColumnOptions(undefined).borderWidth(1).height(100).applyAttributesFinish(); return; - }), undefined, @memo() (() => { + }), @memo() (() => { Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(30); + instance.setTextOptions(this.message.value, undefined).fontSize(30).applyAttributesFinish(); return; - }), this.message.value, undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts index b470b7a10..f4e21d862 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts @@ -38,11 +38,14 @@ const parsedTransform: Plugins = { }; const expectedScript: string = ` +import { TextAttribute as TextAttribute } from "arkui.component.text"; import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -87,7 +90,10 @@ class Per { } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Child._instantiateImpl(undefined, (() => { return new Child(); }), { @@ -119,7 +125,10 @@ class Per { } @memo() public build() { - Text(undefined, this.childVar1.str, undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(this.childVar1.str, undefined).applyAttributesFinish(); + return; + }), undefined); } private constructor() {} diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts index 9857c430b..af43c0416 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts @@ -56,6 +56,8 @@ import { IPropDecoratedVariable as IPropDecoratedVariable } from "arkui.stateMan import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { IObservedObject as IObservedObject } from "arkui.stateManagement.decorator"; @@ -272,7 +274,10 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public ProvideOnChange(propName: string) {} @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Child._instantiateImpl(undefined, (() => { return new Child(); }), undefined, undefined, undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts b/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts index 74d90e249..3da1da620 100644 --- a/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts @@ -42,10 +42,16 @@ import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement. import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; -import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + +import { GridAttribute as GridAttribute } from "arkui.component.grid"; import { GridItemAttribute as GridItemAttribute } from "arkui.component.gridItem"; +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { Bindable as Bindable } from "arkui.component.common"; import { NavInterface as NavInterface } from "arkui.UserView"; @@ -97,29 +103,41 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { - Grid(undefined, undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Grid(@memo() ((instance: GridAttribute): void => { + instance.setGridOptions(undefined, undefined).applyAttributesFinish(); + return; + }), @memo() (() => { GridItem(@memo() ((instance: GridItemAttribute): void => { - instance.selected(({ + instance.setGridItemOptions(undefined).selected(({ value: this.boo, onChange: ((value: boolean) => { this.boo = value; }), - } as Bindable)); + } as Bindable)).applyAttributesFinish(); return; - }), undefined, @memo() (() => { - Text(undefined, "nihao", undefined, undefined); + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("nihao", undefined).applyAttributesFinish(); + return; + }), undefined); })); GridItem(@memo() ((instance: GridItemAttribute): void => { - instance.selected(({ + instance.setGridItemOptions(undefined).selected(({ value: c, onChange: ((value: boolean) => { c = value; }), - } as Bindable)); + } as Bindable)).applyAttributesFinish(); return; - }), undefined, @memo() (() => { - Text(undefined, "nihao", undefined, undefined); + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("nihao", undefined).applyAttributesFinish(); + return; + }), undefined); })); })); })); diff --git a/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts b/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts index dc71b2bd3..01a237aa4 100644 --- a/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts @@ -75,6 +75,8 @@ const expectedCheckedScript: string = ` import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -106,7 +108,10 @@ function main() {} SimpleStruct._instantiateImpl(undefined, (() => { return new SimpleStruct(); }), undefined, undefined, @memo() (() => { - Text(undefined, "a", undefined, undefined); + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions("a", undefined).applyAttributesFinish(); + return; + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts b/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts index 53bb01be8..78f8ba40b 100644 --- a/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts @@ -109,6 +109,8 @@ import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement. import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { TextAttribute as TextAttribute } from "arkui.component.text"; import { memo as memo } from "arkui.stateManagement.runtime"; @@ -182,15 +184,18 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => {})); + instance.setButtonOptions("button", undefined).onClick(((e: ClickEvent) => {})).applyAttributesFinish(); return; - }), "button", undefined, undefined); + }), undefined); Text(@memo() ((instance: TextAttribute): void => { - instance.fontSize(20); + instance.setTextOptions("text", undefined).fontSize(20).applyAttributesFinish(); return; - }), "text", undefined, undefined); + }), undefined); })); } -- Gitee From c2f9db054b5291df983c98027d9d3cee99b42417 Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Mon, 7 Jul 2025 20:17:33 +0800 Subject: [PATCH 4/6] update ut part3 Signed-off-by: VictorS67 Change-Id: I92535e8789b08e1c6c81b33afaadc509b02c5a7f --- .../builder-lambda/simple-component.test.ts | 2 +- .../builder-param-passing.test.ts | 6 +- .../optional-builder-param.test.ts | 8 +- .../storagelink-appstorage.test.ts | 18 +++-- .../storageprop-appstorage.test.ts | 19 +++-- .../wrap-builder/init-with-builder.test.ts | 20 ++++- .../wrap-builder/wrap-builder-in-ui.test.ts | 24 ++++-- .../wrap-builder-with-lambda.test.ts | 77 ++++++++++++++++--- .../builder-lambda-translators/factory.ts | 1 + 9 files changed, 133 insertions(+), 42 deletions(-) diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts index 770835667..b3ecc5bc2 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts @@ -72,7 +72,7 @@ class MyStateSample { __memo_scope.cached; return; } - instance.setColumnOptions(undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); { __memo_scope.recache(); return; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts index 9884aa2f6..add86d585 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts @@ -215,7 +215,7 @@ function main() {} __memo_scope.cached; return; } - instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setTextOptions("Parent builder", undefined).applyAttributesFinish(); { __memo_scope.recache(); return; @@ -240,7 +240,7 @@ function main() {} __memo_scope.cached; return; } - instance.setColumnOptions(undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); { __memo_scope.recache(); return; @@ -287,7 +287,7 @@ function main() {} __memo_scope.cached; return; } - instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setTextOptions("Parent builder", undefined).applyAttributesFinish(); { __memo_scope.recache(); return; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts index 286ca356a..bcd49bb6a 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts @@ -177,7 +177,7 @@ function main() {} __memo_scope.cached; return; } - instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setTextOptions("Hello World", undefined).applyAttributesFinish(); { __memo_scope.recache(); return; @@ -232,7 +232,7 @@ function main() {} __memo_scope.cached; return; } - instance.setRowOptions(undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setRowOptions(undefined).applyAttributesFinish(); { __memo_scope.recache(); return; @@ -283,7 +283,7 @@ function main() {} __memo_scope.cached; return; } - instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setTextOptions("Parent builder", undefined).applyAttributesFinish(); { __memo_scope.recache(); return; @@ -308,7 +308,7 @@ function main() {} __memo_scope.cached; return; } - instance.setColumnOptions(undefined).applyAttributesFinish(); + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); { __memo_scope.recache(); return; diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts index b6d7d10b2..dd5b2170a 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts @@ -40,6 +40,7 @@ const pluginTester = new PluginTester('test storagelink with appstorage', buildC const expectedScript: string = ` import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; import { IStorageLinkDecoratedVariable as IStorageLinkDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; import { NavInterface as NavInterface } from "arkui.UserView"; @@ -100,19 +101,22 @@ class Data { } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Text(@memo() ((instance: TextAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setTextOptions(\`From AppStorage \${this.storageLink}\`, undefined).onClick(((e: ClickEvent) => { this.storageLink += 1; - })); + })).applyAttributesFinish(); return; - }), \`From AppStorage \${this.storageLink}\`, undefined, undefined); + }), undefined); Text(@memo() ((instance: TextAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setTextOptions(\`From AppStorage \${this.storageLinkObject.code}\`, undefined).onClick(((e: ClickEvent) => { this.storageLinkObject.code += 1; - })); + })).applyAttributesFinish(); return; - }), \`From AppStorage \${this.storageLinkObject.code}\`, undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts index cbd0b0844..1a93d87e8 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts @@ -42,6 +42,8 @@ import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement. import { IStoragePropRefDecoratedVariable as IStoragePropRefDecoratedVariable } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; @@ -113,19 +115,22 @@ class Data { } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { Text(@memo() ((instance: TextAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setTextOptions(\`From AppStorage \${this.storageProp}\`, undefined).onClick(((e: ClickEvent) => { this.storageProp += 1; - })); + })).applyAttributesFinish(); return; - }), \`From AppStorage \${this.storageProp}\`, undefined, undefined); + }), undefined); Text(@memo() ((instance: TextAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setTextOptions(\`From AppStorage \${this.storagePropObject.code}\`, undefined).onClick(((e: ClickEvent) => { this.storagePropObject.code += 1; - })); + })).applyAttributesFinish(); return; - }), \`From AppStorage \${this.storagePropObject.code}\`, undefined, undefined); + }), undefined); })); } diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts index 749110403..8e7d6f6c6 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts @@ -92,6 +92,8 @@ const expectedMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; @@ -123,12 +125,12 @@ globalBuilder = wrapBuilder(myBuilder); __memo_scope.cached; return; } - __memo_parameter_instance.value.fontSize(__memo_parameter_size.value); + __memo_parameter_instance.value.setTextOptions(__memo_parameter_value.value, undefined).fontSize(__memo_parameter_size.value).applyAttributesFinish(); { __memo_scope.recache(); return; } - }), __memo_parameter_value.value, undefined, undefined); + }), undefined); { __memo_scope.recache(); return; @@ -149,7 +151,19 @@ globalBuilder = wrapBuilder(myBuilder); __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (213104625)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (213104625)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (211301233)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts index b614702b1..73d6be7a8 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts @@ -112,6 +112,8 @@ function testUITransformer(this: PluginTestContext): void { const expectedMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; @@ -143,12 +145,12 @@ function main() {} __memo_scope.cached; return; } - __memo_parameter_instance.value.fontSize(__memo_parameter_size.value); + __memo_parameter_instance.value.setTextOptions(__memo_parameter_value.value, undefined).fontSize(__memo_parameter_size.value).applyAttributesFinish(); { __memo_scope.recache(); return; } - }), __memo_parameter_value.value, undefined, undefined); + }), undefined); { __memo_scope.recache(); return; @@ -169,12 +171,12 @@ function main() {} __memo_scope.cached; return; } - __memo_parameter_instance.value.fontSize(__memo_parameter_size.value); + __memo_parameter_instance.value.setTextOptions(__memo_parameter_value.value, undefined).fontSize(__memo_parameter_size.value).applyAttributesFinish(); { __memo_scope.recache(); return; } - }), __memo_parameter_value.value, undefined, undefined); + }), undefined); { __memo_scope.recache(); return; @@ -222,7 +224,19 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (54078781)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (54078781)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (213687742)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts index caa6e8154..5797aedec 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts @@ -57,8 +57,12 @@ import { ISubscribedWatches as ISubscribedWatches } from "arkui.stateManagement. import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -77,8 +81,14 @@ function main() {} @memo() function overBuilder(param: (()=> Tmp)) { - Column(undefined, undefined, @memo() (() => { - Text(undefined, \`wrapBuildervalue:\${param().paramA2}\`, undefined, undefined); + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { + Text(@memo() ((instance: TextAttribute): void => { + instance.setTextOptions(\`wrapBuildervalue:\${param().paramA2}\`, undefined).applyAttributesFinish(); + return; + }), undefined); })); } @@ -152,18 +162,21 @@ function main() {} } @memo() public build() { - Column(undefined, undefined, @memo() (() => { + Column(@memo() ((instance: ColumnAttribute): void => { + instance.setColumnOptions(undefined).applyAttributesFinish(); + return; + }), @memo() (() => { wBuilder.builder((() => { return { paramA2: this.label.paramA2, }; })); Button(@memo() ((instance: ButtonAttribute): void => { - instance.onClick(((e: ClickEvent) => { + instance.setButtonOptions("Click me", undefined).onClick(((e: ClickEvent) => { this.label.paramA2 = "ArkUI"; - })); + })).applyAttributesFinish(); return; - }), "Click me", undefined, undefined); + }), undefined); })); } @@ -208,8 +221,12 @@ import { ISubscribedWatches as ISubscribedWatches } from "arkui.stateManagement. import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; +import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; +import { TextAttribute as TextAttribute } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -234,13 +251,37 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (241913892)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (241913892)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (175145513)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (47330804)), undefined, \`wrapBuildervalue:\${__memo_parameter_param.value().paramA2}\`, undefined, undefined); + Text(__memo_context, ((__memo_id) + (47330804)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_instance.value.setTextOptions(\`wrapBuildervalue:\${__memo_parameter_param.value().paramA2}\`, undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), undefined); { __memo_scope.recache(); return; @@ -327,7 +368,19 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (218979098)), undefined, undefined, @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + Column(__memo_context, ((__memo_id) + (218979098)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_instance = __memo_scope.param(0, instance); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_instance.value.setColumnOptions(undefined).applyAttributesFinish(); + { + __memo_scope.recache(); + return; + } + }), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { const __memo_scope = __memo_context.scope(((__memo_id) + (76711614)), 0); if (__memo_scope.unchanged) { __memo_scope.cached; @@ -345,14 +398,14 @@ function main() {} __memo_scope.cached; return; } - __memo_parameter_instance.value.onClick(((e: ClickEvent) => { + __memo_parameter_instance.value.setButtonOptions("Click me", undefined).onClick(((e: ClickEvent) => { this.label.paramA2 = "ArkUI"; - })); + })).applyAttributesFinish(); { __memo_scope.recache(); return; } - }), "Click me", undefined, undefined); + }), undefined); { __memo_scope.recache(); return; diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts index c5a887999..1c68c34c4 100644 --- a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts @@ -182,6 +182,7 @@ export class factory { let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier( BuilderLambdaNames.STYLE_ARROW_PARAM_NAME ); + arkts.NodeCache.getInstance().collect(lambdaBody); const methodName = arkts.factory.createIdentifier(getDeclaredSetAttribtueMethodName(name)); if (!hasReceiver) { lambdaBodyInfo.lambdaBody = arkts.factory.createCallExpression( -- Gitee From 59a75591056e97657a0d29e6624ee9f2cb984a4e Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Mon, 7 Jul 2025 23:07:38 +0800 Subject: [PATCH 5/6] support component Impl Signed-off-by: VictorS67 Change-Id: I0db4bc7cc83bbad82fac6fa56ac97a26496f80a4 --- .../entry/src/main/ets/pages/new.ets | 2 +- .../builder-lambda-translators/factory.ts | 133 ++++++++++++++++-- .../builder-lambda-translators/utils.ts | 26 +++- .../ui-plugins/struct-translators/factory.ts | 10 +- arkui-plugins/ui-plugins/ui-factory.ts | 15 +- 5 files changed, 162 insertions(+), 24 deletions(-) diff --git a/arkui-plugins/test/demo/localtest/entry/src/main/ets/pages/new.ets b/arkui-plugins/test/demo/localtest/entry/src/main/ets/pages/new.ets index a66597507..76b815073 100755 --- a/arkui-plugins/test/demo/localtest/entry/src/main/ets/pages/new.ets +++ b/arkui-plugins/test/demo/localtest/entry/src/main/ets/pages/new.ets @@ -42,7 +42,7 @@ struct MyStateSample { @Component struct Child { - @Link linkVar: string = ""; // TODO: remove this + @Link linkVar: string; @Prop propVar: string = "Prop"; changeValue1() { diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts index 1c68c34c4..db16f4359 100644 --- a/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts @@ -49,7 +49,7 @@ import { getDeclaredSetAttribtueMethodName, BuilderLambdaStyleBodyInfo, checkIsTrailingLambdaInLastParam, - filterParamsExpectTrailingLambda, + getTransformedComponentName, } from './utils'; import { isDecoratorIntrinsicAnnotation } from '../property-translators/utils'; import { factory as PropertyFactory } from '../property-translators/factory'; @@ -62,6 +62,7 @@ import { checkIsMemoFromMemoableInfo, collectMemoableInfoInParameter, } from '../../collectors/memo-collectors/utils'; +import { TypeRecord } from '../../collectors/utils/collect-types'; import { StyleInternalsVisitor } from './style-internals-visitor'; export class factory { @@ -76,8 +77,7 @@ export class factory { ): arkts.MethodDefinition { const func: arkts.ScriptFunction = node.scriptFunction; const isFunctionCall: boolean = node.name.name !== BuilderLambdaNames.ORIGIN_METHOD_NAME; - const restParams = isFunctionCall ? filterParamsExpectTrailingLambda(func.params) : func.params; - const newParams: arkts.Expression[] = [...prefixArgs, ...restParams]; + const newParams: arkts.Expression[] = [...prefixArgs, ...func.params]; const updateFunc = arkts.factory .updateScriptFunction( func, @@ -271,12 +271,12 @@ export class factory { return addMemoAnnotation(arkts.factory.createArrowFunction(func)); } - /* - * create style arguments in builder lambda declaration. + /** + * create style argument in builder lambda declaration. */ static createStyleArgInBuilderLambdaDecl( typeNode: arkts.TypeNode | undefined, - isFunctionCall: boolean + isFunctionCall?: boolean ): arkts.ETSParameterExpression { const styleLambdaParam: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_ARROW_PARAM_NAME, typeNode), @@ -303,6 +303,31 @@ export class factory { return parameter; } + /** + * create content argument in builder lambda declaration. + */ + static createContentArgInBuilderLambdaDecl(): arkts.ETSParameterExpression { + const funcType = arkts.factory.createFunctionType( + arkts.FunctionSignature.createFunctionSignature( + undefined, + [], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + addMemoAnnotation(funcType); + + const parameter: arkts.ETSParameterExpression = arkts.factory + .createParameterDeclaration( + arkts.factory.createIdentifier(BuilderLambdaNames.CONTENT_PARAM_NAME, funcType), + undefined + ) + .setOptional(true); + arkts.NodeCache.getInstance().collect(parameter); + return parameter; + } + /** * If a builder lambda's argument is an arrow function, * then transform any builder lambda in the function body. @@ -440,6 +465,7 @@ export class factory { const modifiedArgs: (arkts.AstNode | undefined)[] = []; const secondLastArgInfo = buildSecondLastArgInfo(type, isFunctionCall); const isTrailingCall = leaf.isTrailingCall; + const typeArguments = leaf.typeArguments; const hasLastTrailingLambda = checkIsTrailingLambdaInLastParam(params); forEachArgWithParam( leaf.arguments, @@ -464,9 +490,9 @@ export class factory { }, { isTrailingCall } ); - const lambdaBody = this.addOptionsArgsToLambdaBodyInStyleArg(lambdaBodyInfo, modifiedArgs, leaf.typeArguments); + const lambdaBody = this.addOptionsArgsToLambdaBodyInStyleArg(lambdaBodyInfo, modifiedArgs, typeArguments); const typeNode = !isFunctionCall && !!type ? UIFactory.createTypeReferenceFromString(type.name) : returnType; - const styleArg = this.createStyleArgInBuilderLambda(lambdaBody, typeNode, moduleName, leaf.typeArguments?.at(0)); + const styleArg = this.createStyleArgInBuilderLambda(lambdaBody, typeNode, moduleName, typeArguments?.at(0)); args.unshift(styleArg); return args; } @@ -558,8 +584,11 @@ export class factory { /** * replace function call's name to the corresponding transformed name. */ - static builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier | arkts.MemberExpression | undefined { - if (!callIsGoodForBuilderLambda(leaf)) { + static builderLambdaReplace( + leaf: arkts.CallExpression, + declInfo: BuilderLambdaDeclInfo | undefined + ): arkts.Identifier | arkts.MemberExpression | undefined { + if (!callIsGoodForBuilderLambda(leaf) || !declInfo) { return undefined; } const node = leaf.expression; @@ -568,6 +597,9 @@ export class factory { return undefined; } if (arkts.isIdentifier(node)) { + const { moduleName } = declInfo; + ImportCollector.getInstance().collectSource(funcName, moduleName); + ImportCollector.getInstance().collectImport(funcName); return arkts.factory.createIdentifier(funcName); } if (arkts.isMemberExpression(node)) { @@ -669,8 +701,11 @@ export class factory { if (!decl) { return node; } - const replace: arkts.Identifier | arkts.MemberExpression | undefined = this.builderLambdaReplace(leaf); const declInfo: BuilderLambdaDeclInfo | undefined = findBuilderLambdaDeclInfo(decl); + const replace: arkts.Identifier | arkts.MemberExpression | undefined = this.builderLambdaReplace( + leaf, + declInfo + ); if (!replace || !declInfo) { return node; } @@ -852,9 +887,79 @@ export class factory { key, flags, returnTypeAnnotation, - modifiers + modifiers, }, - modifiers - }) + modifiers, + }); + } + + /** + * generate `@ComponentBuilder` component Impl function in ETSGLOBAL class + */ + static createDeclaredComponentFunctionFromRecord( + record: ComponentRecord, + attributeName: string, + attributeTypeParams?: TypeRecord[] + ): arkts.MethodDefinition { + const newName: string = getTransformedComponentName(record.name); + const key: arkts.Identifier = arkts.factory.createIdentifier(newName); + const kind = arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD; + const modifiers = + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE | + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC | + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT; + const returnTypeAnnotation = arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID); + const flags = arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD; + const params = factory.createDeclaredComponentFunctionParameters( + attributeName, + attributeTypeParams, + record.hasLastTrailingLambda + ); + const typeParamItems = record.typeParams?.map((p) => TypeFactory.createTypeParameterFromRecord(p)); + const typeParams = !!typeParamItems + ? arkts.factory.createTypeParameterDeclaration(typeParamItems, typeParamItems.length) + : undefined; + const newMethod = UIFactory.createMethodDefinition({ + key, + kind, + function: { + key, + flags, + params, + typeParams, + returnTypeAnnotation, + modifiers, + }, + modifiers, + }); + addMemoAnnotation(newMethod.scriptFunction); + arkts.NodeCache.getInstance().collect(newMethod); + return newMethod; + } + + /** + * generate parameters in `@ComponentBuilder` component Impl function + */ + static createDeclaredComponentFunctionParameters( + attributeName: string, + attributeTypeParams?: TypeRecord[], + hasLastTrailingLambda?: boolean + ): arkts.ETSParameterExpression[] { + const params: arkts.ETSParameterExpression[] = []; + + const typeParamItems = attributeTypeParams?.map((p) => TypeFactory.createTypeNodeFromRecord(p)); + const typeParams = !!typeParamItems + ? arkts.factory.createTSTypeParameterInstantiation(typeParamItems) + : undefined; + const typeNode: arkts.TypeNode = UIFactory.createTypeReferenceFromString(attributeName, typeParams); + const styleArg: arkts.ETSParameterExpression = this.createStyleArgInBuilderLambdaDecl(typeNode, true); + params.push(styleArg); + + if (!!hasLastTrailingLambda) { + const contentArg: arkts.ETSParameterExpression = this.createContentArgInBuilderLambdaDecl(); + params.push(contentArg); + } + + return params; } } diff --git a/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts b/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts index ab12e3245..1ccf6a3f4 100644 --- a/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts +++ b/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts @@ -22,8 +22,10 @@ import { ImportCollector } from '../../common/import-collector'; import { collectTypeRecordFromParameter, collectTypeRecordFromTypeParameterDeclaration, + collectTypeRecordFromTypeParameterInstatiation, ParameterRecord, TypeParameterTypeRecord, + TypeRecord, } from '../../collectors/utils/collect-types'; import { hasMemoAnnotation } from '../../collectors/memo-collectors/utils'; import { AstNodePointer } from 'common/safe-types'; @@ -434,7 +436,7 @@ export function builderLambdaFunctionName(node: arkts.CallExpression): string | return undefined; } if (arkts.isIdentifier(node.expression)) { - return node.expression.name; + return getTransformedComponentName(node.expression.name); } if ( arkts.isMemberExpression(node.expression) && @@ -590,9 +592,7 @@ export function checkIsTrailingLambdaInLastParam(params: readonly arkts.Expressi /** * remove any parameters except possible last trailing lambda parameter in components. */ -export function filterParamsExpectTrailingLambda( - params: readonly arkts.Expression[] -): readonly arkts.Expression[] { +export function filterParamsExpectTrailingLambda(params: readonly arkts.Expression[]): readonly arkts.Expression[] { if (checkIsTrailingLambdaInLastParam(params)) { return [params.at(params.length - 1)!]; } @@ -619,6 +619,13 @@ export function getDeclaredSetAttribtueMethodName(componentName: string): string return `set${componentName}Options`; } +/** + * get after-transformed component name + */ +export function getTransformedComponentName(componentName: string): string { + return `${componentName}Impl`; +} + // CACHE export interface ComponentRecord { name: string; @@ -626,11 +633,13 @@ export interface ComponentRecord { typeParams?: TypeParameterTypeRecord[]; hasRestParameter?: boolean; hasReceiver?: boolean; + hasLastTrailingLambda?: boolean; } export class ComponentAttributeCache { private _cache: Map; private _attributeName: string | undefined; + private _attributeTypeParams: TypeRecord[] | undefined; private _isCollected: boolean = false; private static instance: ComponentAttributeCache; @@ -656,15 +665,23 @@ export class ComponentAttributeCache { return; } this._attributeName = type.part.name.name; + if (type.part.typeParams) { + this._attributeTypeParams = collectTypeRecordFromTypeParameterInstatiation(type.part.typeParams); + } } get attributeName(): string | undefined { return this._attributeName; } + get attributeTypeParams(): TypeRecord[] | undefined { + return this._attributeTypeParams; + } + reset(): void { this._cache.clear(); this._attributeName = undefined; + this._attributeTypeParams = undefined; this._isCollected = false; } @@ -697,6 +714,7 @@ export class ComponentAttributeCache { typeParams, hasRestParameter, hasReceiver, + hasLastTrailingLambda, }; this._cache.set(name, componentRecord); this._isCollected = true; diff --git a/arkui-plugins/ui-plugins/struct-translators/factory.ts b/arkui-plugins/ui-plugins/struct-translators/factory.ts index 9cad2c674..00768a14b 100644 --- a/arkui-plugins/ui-plugins/struct-translators/factory.ts +++ b/arkui-plugins/ui-plugins/struct-translators/factory.ts @@ -21,7 +21,7 @@ import { getTypeNameFromTypeParameter, getTypeParamsFromClassDecl, isCustomComponentInterface, - isKnownMethodDefinition + isKnownMethodDefinition, } from '../utils'; import { factory as uiFactory } from '../ui-factory'; import { factory as propertyFactory } from '../property-translators/factory'; @@ -691,6 +691,14 @@ export class factory { } return member; }); + if (ComponentAttributeCache.getInstance().isCollected()) { + const record = ComponentAttributeCache.getInstance().getAllComponentRecords().at(0)!; + const name = ComponentAttributeCache.getInstance().attributeName!; + const typeParams = ComponentAttributeCache.getInstance().attributeTypeParams; + updatedBody.push( + builderLambdaFactory.createDeclaredComponentFunctionFromRecord(record, name, typeParams) + ); + } return arkts.factory.updateClassDeclaration( node, arkts.factory.updateClassDefinition( diff --git a/arkui-plugins/ui-plugins/ui-factory.ts b/arkui-plugins/ui-plugins/ui-factory.ts index f6718b652..8d732252c 100644 --- a/arkui-plugins/ui-plugins/ui-factory.ts +++ b/arkui-plugins/ui-plugins/ui-factory.ts @@ -144,10 +144,17 @@ export class factory { /** * create type from string */ - static createTypeReferenceFromString(name: string): arkts.TypeNode { - return arkts.factory.createTypeReference( - arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(name)) - ); + static createTypeReferenceFromString( + name: string, + typeParams?: arkts.TSTypeParameterInstantiation + ): arkts.TypeNode { + let part: arkts.ETSTypeReferencePart; + if (!!typeParams) { + part = arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(name), typeParams); + } else { + part = arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(name)); + } + return arkts.factory.createTypeReference(part); } /** -- Gitee From 0d0ab80d198993c1437afe1ad4abfad7da36f679 Mon Sep 17 00:00:00 2001 From: VictorS67 Date: Tue, 8 Jul 2025 09:27:14 +0800 Subject: [PATCH 6/6] update ut Signed-off-by: VictorS67 Change-Id: Id8d99d204c66d24141b778a5c4c7c1b313097353 --- .../animation/animatable-extend-basic.test.ts | 8 +++-- .../animation/animation-basic.test.ts | 8 +++-- .../custom-component-call.test.ts | 12 +++++--- .../builder-lambda/simple-component.test.ts | 6 ++-- .../style-with-receiver.test.ts | 10 +++++-- .../ut/ui-plugins/component/for-each.test.ts | 12 +++++--- .../builder-param-passing.test.ts | 18 +++++++---- .../optional-builder-param.test.ts | 22 +++++++++----- .../decorators/builder/global-builder.test.ts | 12 +++++--- .../decorators/builder/local-builder.test.ts | 10 +++++-- .../link/link-to-link-prop-state.test.ts | 10 +++++-- .../decorators/link/state-to-link.test.ts | 22 +++++++++----- .../objectlink/objectlink-observed.test.ts | 14 +++++---- .../decorators/prop/state-to-prop.test.ts | 22 +++++++++----- .../resource/resource-in-build.test.ts | 30 +++++++++++++------ .../resource/resource-in-property.test.ts | 11 ++++--- .../reusable/reusable-complex.test.ts | 14 ++++++--- .../decorators/state/state-to-state.test.ts | 8 +++-- .../storagelink-appstorage.test.ts | 8 +++-- .../storageprop-appstorage.test.ts | 10 +++++-- .../decorators/watch/watch-basic.test.ts | 4 ++- .../double-dollar-griditem.test.ts | 20 +++++++++---- .../ui-plugins/imports/import-struct.test.ts | 4 ++- .../ut/ui-plugins/imports/kit-import.test.ts | 12 ++++++-- .../wrap-builder/init-with-builder.test.ts | 14 ++++++--- .../wrap-builder/wrap-builder-in-ui.test.ts | 20 +++++++++---- .../wrap-builder-with-lambda.test.ts | 28 ++++++++++++----- 27 files changed, 253 insertions(+), 116 deletions(-) diff --git a/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts index b680bfe9f..850be5ba9 100644 --- a/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/animation/animatable-extend-basic.test.ts @@ -45,6 +45,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -77,11 +81,11 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public __updateStruct(initializers: (__Options_AnimatablePropertyExample | undefined)): void {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("AnimatableProperty", undefined).animationStart({ duration: 2000, curve: Curve.Ease, diff --git a/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts index 94ee904c0..6cf2fc9d7 100644 --- a/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts @@ -44,6 +44,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -76,11 +80,11 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public __updateStruct(initializers: (__Options_AnimatablePropertyExample | undefined)): void {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("AnimatableProperty", undefined).animationStart({ duration: 2000, curve: Curve.Ease, diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts index 62ef61a2b..932cce904 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts @@ -104,6 +104,10 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -150,18 +154,18 @@ function main() {} public __updateStruct(initializers: (__Options_CustomContainerUser | undefined)): void {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { CustomContainer._instantiateImpl(undefined, (() => { return new CustomContainer(); }), undefined, undefined, @memo() (() => { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("hello", undefined).applyAttributesFinish(); return; }), undefined); @@ -170,7 +174,7 @@ function main() {} CustomContainer._instantiateImpl(undefined, (() => { return new CustomContainer(); }), {}, undefined, @memo() (() => { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => {})); diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts index b3ecc5bc2..d660394e1 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts @@ -34,12 +34,13 @@ function testBuilderLambdaTransformer(this: PluginTestContext): void { const expectedScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { memo as memo } from \"@ohos.arkui.stateManagement\"; import { Column as Column, ColumnAttribute as ColumnAttribute } from \"arkui.component.column\"; function main() {} class MyStateSample { @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => {})); @@ -55,6 +56,7 @@ function testMemoTransformer(this: PluginTestContext): void { import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"arkui.stateManagement.runtime\"; import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { memo as memo } from \"@ohos.arkui.stateManagement\"; import { Column as Column, ColumnAttribute as ColumnAttribute } from \"arkui.component.column\"; function main() {} @@ -65,7 +67,7 @@ class MyStateSample { __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { diff --git a/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts b/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts index da840d684..079f19ff4 100644 --- a/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts @@ -45,6 +45,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -78,15 +82,15 @@ function main() {} public __updateStruct(initializers: (__Options_MM | undefined)): void {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { style22(cardStyle(instance.setTextOptions("hello world", undefined).height(200).fontColor("#000000"), 600, "#eeeeee").fontSize(60).fontWeight(400)).width(900).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { cardStyle(instance.setTextOptions("hello world", undefined), 600, "#eeeeee").applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts b/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts index 2f801522f..21e842c9c 100644 --- a/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/component/for-each.test.ts @@ -40,10 +40,14 @@ const parsedTransform: Plugins = { const expectedScript: string = ` import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -102,14 +106,14 @@ class AB { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { ForEach(((): Array => { return this.arr; }), ((item: string) => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(item, undefined).applyAttributesFinish(); return; }), undefined); @@ -117,7 +121,7 @@ class AB { ForEach(((): Array => { return this.getArray(); }), ((item: Person) => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(item.name, undefined).applyAttributesFinish(); return; }), undefined); @@ -125,7 +129,7 @@ class AB { ForEach(((): Array => { return new AB().bar; }), ((item: string) => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(item, undefined).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts index add86d585..a1f802675 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts @@ -40,8 +40,12 @@ const parsedTransform: Plugins = { const expectedAfterUIScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -88,14 +92,14 @@ function main() {} public __updateStruct(initializers: (__Options_Parent | undefined)): void {} @memo() public componentBuilder() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); return; }), undefined); } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -114,7 +118,7 @@ function main() {} Child._instantiateImpl(undefined, (() => { return new Child(); }), undefined, undefined, @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); return; }), undefined); @@ -141,7 +145,9 @@ function main() {} const expectedAfterMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; import { memo as memo } from "arkui.stateManagement.runtime"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -208,7 +214,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (137225318)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (137225318)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -233,7 +239,7 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (136716185)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (136716185)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -280,7 +286,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (223657391)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (223657391)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts index bcd49bb6a..1220e20c6 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/optional-builder-param.test.ts @@ -39,9 +39,12 @@ const parsedTransform: Plugins = { const expectedUIScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { RowAttribute as RowAttribute } from "arkui.component.row"; +import { RowImpl as RowImpl } from "arkui.component.row"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; @@ -50,7 +53,7 @@ import { Component as Component, Entry as Entry, Builder as Builder, BuilderPara function main() {} @memo() function showTextBuilder() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); return; }), undefined); @@ -87,7 +90,7 @@ function main() {} } @memo() public build() { - Row(@memo() ((instance: RowAttribute): void => { + RowImpl(@memo() ((instance: RowAttribute): void => { instance.setRowOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -111,14 +114,14 @@ function main() {} public __updateStruct(initializers: (__Options_Parent | undefined)): void {} @memo() public componentBuilder() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Parent builder", undefined).applyAttributesFinish(); return; }), undefined); } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -154,9 +157,12 @@ function main() {} const expectedMemoScript: string = ` import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { RowAttribute as RowAttribute } from "arkui.component.row"; +import { RowImpl as RowImpl } from "arkui.component.row"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; @@ -170,7 +176,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -225,7 +231,7 @@ function main() {} __memo_scope.cached; return; } - Row(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: RowAttribute): void => { + RowImpl(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: RowAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -276,7 +282,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -301,7 +307,7 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (78055758)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (78055758)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts index 903569d5a..3cbcc3999 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts @@ -39,10 +39,14 @@ const expectedScript: string = ` import { RowAttribute as RowAttribute } from "arkui.component.row"; +import { RowImpl as RowImpl } from "arkui.component.row"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -55,18 +59,18 @@ function main() {} @memo() function showTextBuilder() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Hello World", undefined).applyAttributesFinish(); return; }), undefined); } @memo() function overBuilder(params: Tmp) { - Row(@memo() ((instance: RowAttribute): void => { + RowImpl(@memo() ((instance: RowAttribute): void => { instance.setRowOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions((("UseStateVarByReference: ") + (params.paramA1)), undefined).applyAttributesFinish(); return; }), undefined); @@ -87,7 +91,7 @@ class Tmp { public __updateStruct(initializers: (__Options_BuilderDemo | undefined)): void {} @memo() public build() { - Row(@memo() ((instance: RowAttribute): void => { + RowImpl(@memo() ((instance: RowAttribute): void => { instance.setRowOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts index e299d9ac4..6b3f935b2 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts @@ -38,10 +38,14 @@ const parsedTransform: Plugins = { const expectedScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -60,21 +64,21 @@ function main() {} public __updateStruct(initializers: (__Options_BuilderDemo | undefined)): void {} @memo() public showTextBuilder() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Hello World", undefined).fontSize(30).applyAttributesFinish(); return; }), undefined); } @memo() public showTextValueBuilder(param: string) { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(param, undefined).fontSize(30).applyAttributesFinish(); return; }), undefined); } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts index 9dd321279..14f9ab48b 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts @@ -54,6 +54,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextInputAttribute as TextInputAttribute } from "arkui.component.textInput"; +import { TextInputImpl as TextInputImpl } from "arkui.component.textInput"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -87,11 +91,11 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - TextInput(@memo() ((instance: TextInputAttribute): void => { + TextInputImpl(@memo() ((instance: TextInputAttribute): void => { instance.setTextInputOptions({ text: this.text1, }).applyAttributesFinish(); @@ -177,7 +181,7 @@ function main() {} } @memo() public build() { - TextInput(@memo() ((instance: TextInputAttribute): void => { + TextInputImpl(@memo() ((instance: TextInputAttribute): void => { instance.setTextInputOptions({ text: this.childText, }).applyAttributesFinish(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts index 3f3722d66..1e9d1a3ec 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts @@ -50,10 +50,16 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { DatePickerAttribute as DatePickerAttribute } from "arkui.component.datePicker"; +import { DatePickerImpl as DatePickerImpl } from "arkui.component.datePicker"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -101,23 +107,23 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("child increase the year by 1", undefined).onClick(((e: ClickEvent) => { this.selectedDate.setFullYear(((this.selectedDate.getFullYear()) + (1))); })).applyAttributesFinish(); return; }), undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("child update the new date", undefined).margin(10).onClick(((e: ClickEvent) => { this.selectedDate = new Date("2023-09-09"); })).applyAttributesFinish(); return; }), undefined); - DatePicker(@memo() ((instance: DatePickerAttribute): void => { + DatePickerImpl(@memo() ((instance: DatePickerAttribute): void => { instance.setDatePickerOptions({ start: new Date("1970-1-1"), end: new Date("2100-1-1"), @@ -151,23 +157,23 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("parent increase the month by 1", undefined).margin(10).onClick(((e: ClickEvent) => { this.parentSelectedDate.setMonth(((this.parentSelectedDate.getMonth()) + (1))); })).applyAttributesFinish(); return; }), undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("parent update the new date", undefined).margin(10).onClick(((e: ClickEvent) => { this.parentSelectedDate = new Date("2023-07-07"); })).applyAttributesFinish(); return; }), undefined); - DatePicker(@memo() ((instance: DatePickerAttribute): void => { + DatePickerImpl(@memo() ((instance: DatePickerAttribute): void => { instance.setDatePickerOptions({ start: new Date("1970-1-1"), end: new Date("2100-1-1"), diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts index 78e5bb8b0..668b7487a 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/objectlink/objectlink-observed.test.ts @@ -49,6 +49,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { IObservedObject as IObservedObject } from "arkui.stateManagement.decorator"; import { OBSERVE as OBSERVE } from "arkui.stateManagement.decorator"; @@ -206,11 +210,11 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("child increase the day by 1", undefined).onClick(((e: ClickEvent) => { this.data.setDate(((this.data.getDate()) + (1))); })).applyAttributesFinish(); @@ -242,7 +246,7 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -252,13 +256,13 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ label: "date", data: this.newData.data, }, undefined, undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("parent update the new date", undefined).onClick(((e: ClickEvent) => { this.newData.data = new DateClass("2023-07-07"); })).applyAttributesFinish(); return; }), undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("ViewB: this.newData = new NewDate(new DateClass('2023-08-20'))", undefined).onClick(((e: ClickEvent) => { this.newData = new NewDate(new DateClass("2023-08-20")); })).applyAttributesFinish(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts index 2b27545fb..049d3b729 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts @@ -48,10 +48,16 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -100,22 +106,22 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { if (((this.count) > (0))) { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions((((("You have") + (this.count))) + ("Nuggets left")), undefined).applyAttributesFinish(); return; }), undefined); } else { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("Game over!", undefined).applyAttributesFinish(); return; }), undefined); } - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("Try again", undefined).onClick(((e: ClickEvent) => { this.count -= this.costOfOneAttempt; })).applyAttributesFinish(); @@ -147,21 +153,21 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions((((("Grant") + (this.countDownStartValue))) + ("nuggets to play.")), undefined).applyAttributesFinish(); return; }), undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("+1 - Nuggets in New Game", undefined).onClick(((e: ClickEvent) => { this.countDownStartValue += 1; })).applyAttributesFinish(); return; }), undefined); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("-1 - Nuggets in New Game", undefined).onClick(((e: ClickEvent) => { this.countDownStartValue -= 1; })).applyAttributesFinish(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts index 66a315c3d..6a45a6bd2 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts @@ -44,16 +44,28 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { ImageAnimatorAttribute as ImageAnimatorAttribute } from "arkui.component.imageAnimator"; +import { ImageAnimatorImpl as ImageAnimatorImpl } from "arkui.component.imageAnimator"; + import { SelectAttribute as SelectAttribute } from "arkui.component.select"; +import { SelectImpl as SelectImpl } from "arkui.component.select"; + import { TextInputAttribute as TextInputAttribute } from "arkui.component.textInput"; +import { TextInputImpl as TextInputImpl } from "arkui.component.textInput"; + import { ImageAttribute as ImageAttribute } from "arkui.component.image"; +import { ImageImpl as ImageImpl } from "arkui.component.image"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { _r as _r } from "arkui.component.resources"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -117,33 +129,33 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(_r(16777216, 10003, "com.example.mock", "entry"), undefined).applyAttributesFinish(); return; }), undefined); - Image(@memo() ((instance: ImageAttribute): void => { + ImageImpl(@memo() ((instance: ImageAttribute): void => { instance.setImageOptions(_rawfile(0, 30000, "com.example.mock", "entry", "app.mock.txt"), undefined).applyAttributesFinish(); return; }), undefined); - TextInput(@memo() ((instance: TextInputAttribute): void => { + TextInputImpl(@memo() ((instance: TextInputAttribute): void => { instance.setTextInputOptions({ text: _r(16777220, 10003, "com.example.mock", "entry"), }).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(_r(-1, -1, "com.example.mock", "entry", this.str1), undefined).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(_r(-1, -1, "com.example.mock", "entry", this.str2), undefined).applyAttributesFinish(); return; }), undefined); - Select(@memo() ((instance: SelectAttribute): void => { + SelectImpl(@memo() ((instance: SelectAttribute): void => { instance.setSelectOptions(new Array({ value: "aaa", icon: _r(16777223, 20000, "com.example.mock", "entry"), @@ -159,14 +171,14 @@ function main() {} })).applyAttributesFinish(); return; }), undefined); - Image(@memo() ((instance: ImageAttribute): void => { + ImageImpl(@memo() ((instance: ImageAttribute): void => { instance.setImageOptions(_r(16777217, 20000, "com.example.mock", "entry"), undefined).margin(({ top: _r(16777222, 10002, "com.example.mock", "entry"), bottom: _r(16777222, 10002, "com.example.mock", "entry"), } as Margin)).applyAttributesFinish(); return; }), undefined); - ImageAnimator(@memo() ((instance: ImageAnimatorAttribute): void => { + ImageAnimatorImpl(@memo() ((instance: ImageAnimatorAttribute): void => { instance.setImageAnimatorOptions().images([{ src: _r(16777217, 20000, "com.example.mock", "entry"), }, { diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts index e1c06c5a9..dc2b6e0fd 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts @@ -40,8 +40,11 @@ const parsedTransform: Plugins = { const expectedScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { ImageAttribute as ImageAttribute } from "arkui.component.image"; +import { ImageImpl as ImageImpl } from "arkui.component.image"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { _rawfile as _rawfile } from "arkui.component.resources"; import { _r as _r } from "arkui.component.resources"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; @@ -78,19 +81,19 @@ i = _r(16777216, 10003, "com.example.mock", "entry"); } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(this.str, undefined).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(i, undefined).applyAttributesFinish(); return; }), undefined); - Image(@memo() ((instance: ImageAttribute): void => { + ImageImpl(@memo() ((instance: ImageAttribute): void => { instance.setImageOptions(this.icon, undefined).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts index fe775048f..7b9250b8f 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts @@ -41,6 +41,8 @@ const expectedScript: string = ` import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; @@ -51,6 +53,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -105,11 +111,11 @@ class Message { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).height("100%").width("100%").applyAttributesFinish(); return; }), @memo() (() => { - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("Hello", undefined).fontSize(30).fontWeight(FontWeight.Bold).onClick(((e: ClickEvent) => { this.display = !(this.display); })).applyAttributesFinish(); @@ -159,11 +165,11 @@ class Message { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).borderWidth(1).height(100).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(this.message.value, undefined).fontSize(30).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts index f4e21d862..cf716891b 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts @@ -40,6 +40,8 @@ const parsedTransform: Plugins = { const expectedScript: string = ` import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { STATE_MGMT_FACTORY as STATE_MGMT_FACTORY } from "arkui.stateManagement.decorator"; import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateManagement.decorator"; @@ -48,6 +50,8 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -90,7 +94,7 @@ class Per { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -125,7 +129,7 @@ class Per { } @memo() public build() { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(this.childVar1.str, undefined).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts index dd5b2170a..6544ab5c7 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts @@ -43,6 +43,8 @@ import { IStorageLinkDecoratedVariable as IStorageLinkDecoratedVariable } from " import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; import { EntryPoint as EntryPoint } from "arkui.UserView"; @@ -101,17 +103,17 @@ class Data { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(\`From AppStorage \${this.storageLink}\`, undefined).onClick(((e: ClickEvent) => { this.storageLink += 1; })).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(\`From AppStorage \${this.storageLinkObject.code}\`, undefined).onClick(((e: ClickEvent) => { this.storageLinkObject.code += 1; })).applyAttributesFinish(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts index 1a93d87e8..d048e1f0c 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts @@ -48,6 +48,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -115,17 +119,17 @@ class Data { } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(\`From AppStorage \${this.storageProp}\`, undefined).onClick(((e: ClickEvent) => { this.storageProp += 1; })).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(\`From AppStorage \${this.storagePropObject.code}\`, undefined).onClick(((e: ClickEvent) => { this.storagePropObject.code += 1; })).applyAttributesFinish(); diff --git a/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts b/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts index af43c0416..5c28732ef 100644 --- a/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts @@ -60,6 +60,8 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { IObservedObject as IObservedObject } from "arkui.stateManagement.decorator"; import { OBSERVE as OBSERVE } from "arkui.stateManagement.decorator"; @@ -274,7 +276,7 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ public ProvideOnChange(propName: string) {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { diff --git a/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts b/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts index 3da1da620..4463a0030 100644 --- a/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/double-dollar/double-dollar-griditem.test.ts @@ -52,8 +52,16 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { Bindable as Bindable } from "arkui.component.common"; +import { GridItemImpl as GridItemImpl } from "arkui.component.gridItem"; + +import { GridImpl as GridImpl } from "arkui.component.grid"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -103,15 +111,15 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Grid(@memo() ((instance: GridAttribute): void => { + GridImpl(@memo() ((instance: GridAttribute): void => { instance.setGridOptions(undefined, undefined).applyAttributesFinish(); return; }), @memo() (() => { - GridItem(@memo() ((instance: GridItemAttribute): void => { + GridItemImpl(@memo() ((instance: GridItemAttribute): void => { instance.setGridItemOptions(undefined).selected(({ value: this.boo, onChange: ((value: boolean) => { @@ -120,12 +128,12 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } as Bindable)).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("nihao", undefined).applyAttributesFinish(); return; }), undefined); })); - GridItem(@memo() ((instance: GridItemAttribute): void => { + GridItemImpl(@memo() ((instance: GridItemAttribute): void => { instance.setGridItemOptions(undefined).selected(({ value: c, onChange: ((value: boolean) => { @@ -134,7 +142,7 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } as Bindable)).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("nihao", undefined).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts b/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts index 01a237aa4..0e9102f08 100644 --- a/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/imports/import-struct.test.ts @@ -77,6 +77,8 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -108,7 +110,7 @@ function main() {} SimpleStruct._instantiateImpl(undefined, (() => { return new SimpleStruct(); }), undefined, undefined, @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("a", undefined).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts b/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts index 78f8ba40b..7eabfe3d6 100644 --- a/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/imports/kit-import.test.ts @@ -113,10 +113,16 @@ import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { NavInterface as NavInterface } from "arkui.UserView"; import { PageLifeCycle as PageLifeCycle } from "arkui.component.customComponent"; @@ -184,15 +190,15 @@ __EntryWrapper.RegisterNamedRouter("", new __EntryWrapper(), ({ } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("button", undefined).onClick(((e: ClickEvent) => {})).applyAttributesFinish(); return; }), undefined); - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions("text", undefined).fontSize(20).applyAttributesFinish(); return; }), undefined); diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts index 8e7d6f6c6..b7b786f6e 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/init-with-builder.test.ts @@ -39,8 +39,10 @@ const parsedTransform: Plugins = { const expectedUIScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; @@ -52,7 +54,7 @@ function main() {} globalBuilder = wrapBuilder(myBuilder); @memo() function myBuilder(value: string, size: number) { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; }), undefined); @@ -67,7 +69,7 @@ globalBuilder = wrapBuilder(myBuilder); public __updateStruct(initializers: (__Options_ImportStruct | undefined)): void {} @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -94,10 +96,14 @@ import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -118,7 +124,7 @@ globalBuilder = wrapBuilder(myBuilder); __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (175145513)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (175145513)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + (47330804)), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -151,7 +157,7 @@ globalBuilder = wrapBuilder(myBuilder); __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (213104625)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (213104625)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts index 73d6be7a8..45c1a805e 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-in-ui.test.ts @@ -40,10 +40,14 @@ const parsedTransform: Plugins = { const expectedUIScript: string = ` import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -58,14 +62,14 @@ function main() {} @memo() function myBuilder(value: string, size: number) { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; }), undefined); } @memo() function yourBuilder(value: string, size: number) { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(value, undefined).fontSize(size).applyAttributesFinish(); return; }), undefined); @@ -88,7 +92,7 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -114,10 +118,14 @@ import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id import { ColumnAttribute as ColumnAttribute } from "arkui.component.column"; +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -138,7 +146,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (175145513)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (175145513)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + (47330804)), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -164,7 +172,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (211301233)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (211301233)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + (137225318)), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -224,7 +232,7 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (54078781)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (54078781)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { diff --git a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts index 5797aedec..06ce39ccf 100644 --- a/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts +++ b/arkui-plugins/test/ut/ui-plugins/wrap-builder/wrap-builder-with-lambda.test.ts @@ -43,6 +43,8 @@ import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateM import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + import { IObservedObject as IObservedObject } from "arkui.stateManagement.decorator"; import { OBSERVE as OBSERVE } from "arkui.stateManagement.decorator"; @@ -63,6 +65,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -81,11 +87,11 @@ function main() {} @memo() function overBuilder(param: (()=> Tmp)) { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { - Text(@memo() ((instance: TextAttribute): void => { + TextImpl(@memo() ((instance: TextAttribute): void => { instance.setTextOptions(\`wrapBuildervalue:\${param().paramA2}\`, undefined).applyAttributesFinish(); return; }), undefined); @@ -162,7 +168,7 @@ function main() {} } @memo() public build() { - Column(@memo() ((instance: ColumnAttribute): void => { + ColumnImpl(@memo() ((instance: ColumnAttribute): void => { instance.setColumnOptions(undefined).applyAttributesFinish(); return; }), @memo() (() => { @@ -171,7 +177,7 @@ function main() {} paramA2: this.label.paramA2, }; })); - Button(@memo() ((instance: ButtonAttribute): void => { + ButtonImpl(@memo() ((instance: ButtonAttribute): void => { instance.setButtonOptions("Click me", undefined).onClick(((e: ClickEvent) => { this.label.paramA2 = "ArkUI"; })).applyAttributesFinish(); @@ -207,6 +213,8 @@ import { IStateDecoratedVariable as IStateDecoratedVariable } from "arkui.stateM import { ButtonAttribute as ButtonAttribute } from "arkui.component.button"; +import { ButtonImpl as ButtonImpl } from "arkui.component.button"; + import { IObservedObject as IObservedObject } from "arkui.stateManagement.decorator"; import { OBSERVE as OBSERVE } from "arkui.stateManagement.decorator"; @@ -227,6 +235,10 @@ import { memo as memo } from "arkui.stateManagement.runtime"; import { TextAttribute as TextAttribute } from "arkui.component.text"; +import { TextImpl as TextImpl } from "arkui.component.text"; + +import { ColumnImpl as ColumnImpl } from "arkui.component.column"; + import { LayoutCallback as LayoutCallback } from "arkui.component.customComponent"; import { CustomComponentV2 as CustomComponentV2 } from "arkui.component.customComponent"; @@ -251,7 +263,7 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (241913892)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (241913892)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -269,7 +281,7 @@ function main() {} __memo_scope.cached; return; } - Text(__memo_context, ((__memo_id) + (47330804)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { + TextImpl(__memo_context, ((__memo_id) + (47330804)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: TextAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -368,7 +380,7 @@ function main() {} __memo_scope.cached; return; } - Column(__memo_context, ((__memo_id) + (218979098)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { + ColumnImpl(__memo_context, ((__memo_id) + (218979098)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ColumnAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { @@ -391,7 +403,7 @@ function main() {} paramA2: this.label.paramA2, }; })); - Button(__memo_context, ((__memo_id) + (46726221)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ButtonAttribute): void => { + ButtonImpl(__memo_context, ((__memo_id) + (46726221)), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: ButtonAttribute): void => { const __memo_scope = __memo_context.scope(((__memo_id) + (213104625)), 1); const __memo_parameter_instance = __memo_scope.param(0, instance); if (__memo_scope.unchanged) { -- Gitee