@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSTypeReferencePart.ts

@@ -0,0 +1,36 @@
+/*
+ * 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 { ETSTypeReferencePart, Expression, TSTypeParameterInstantiation } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSTypeReferencePart(
+    original: ETSTypeReferencePart,
+    name?: Expression,
+    typeParams?: TSTypeParameterInstantiation,
+    prev?: ETSTypeReferencePart
+): ETSTypeReferencePart {
+    if (
+        isSameNativeObject(name, original.name) &&
+        isSameNativeObject(typeParams, original.typeParams) &&
+        isSameNativeObject(prev, original.previous)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSTypeReferencePart.updateETSTypeReferencePart, attachModifiers);
+    return update(original, name, typeParams, prev);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSUndefinedType.ts

@@ -0,0 +1,24 @@
+/*
+ * 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 { ETSUndefinedType } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSUndefinedType(original: ETSUndefinedType): ETSUndefinedType {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(ETSUndefinedType.updateETSUndefinedType, attachModifiers);
+    return update(original);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSUnionType.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { ETSUnionType, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[]): ETSUnionType {
+    if (isSameNativeObject(types, original.types)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSUnionType.updateETSUnionType, attachModifiers);
+    return update(original, types);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/Identifier.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { Identifier, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateIdentifier(original: Identifier, name: string, typeAnnotation?: TypeNode): Identifier {
+    if (isSameNativeObject(name, original.name) && isSameNativeObject(typeAnnotation, original.typeAnnotation)) {
+        return original;
+    }
+
+    const update = updateThenAttach(Identifier.update2Identifier, attachModifiers);
+    return update(original, name, typeAnnotation);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ImportSpecifier.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 { Identifier, ImportSpecifier } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateImportSpecifier(
+    original: ImportSpecifier,
+    imported?: Identifier,
+    local?: Identifier
+): ImportSpecifier {
+    if (isSameNativeObject(imported, original.imported) && isSameNativeObject(local, original.local)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ImportSpecifier.updateImportSpecifier, attachModifiers);
+    return update(original, imported, local);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/MemberExpression.ts

@@ -25,7 +25,7 @@ export function updateMemberExpression(
     kind: Es2pandaMemberExpressionKind,
     computed: boolean,
     optional_arg: boolean
-) {
+): MemberExpression {
     if (isSameNativeObject(object_arg, original.object)
         && isSameNativeObject(property, original.property)
         && isSameNativeObject(kind, original.kind)

package/build/libarkts-copy/src/arkts-api/node-utilities/MethodDefinition.ts

@@ -29,7 +29,7 @@ export function createMethodDefinition(
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     overloads?: readonly MethodDefinition[]
-) {
+): MethodDefinition {
     const res = MethodDefinition.createMethodDefinition(
         kind,
         key,
@@ -51,7 +51,7 @@ export function updateMethodDefinition(
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     overloads?: readonly MethodDefinition[]
-) {
+): MethodDefinition {
     if (isSameNativeObject(kind, original.kind)
         && isSameNativeObject(key, original.key)
         && isSameNativeObject(value, original.value)

package/build/libarkts-copy/src/arkts-api/node-utilities/NullLiteral.ts

@@ -0,0 +1,24 @@
+/*
+ * 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 { NullLiteral } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateNullLiteral(original: NullLiteral): NullLiteral {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(NullLiteral.updateNullLiteral, attachModifiers);
+    return update(original);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/NumberLiteral.ts

@@ -20,7 +20,7 @@ import { updateNodeByNode } from "../utilities/private"
 
 export function createNumberLiteral(
     value: number
-) {
+): NumberLiteral {
     return new NumberLiteral(
         global.es2panda._CreateNumberLiteral(
             global.context,
@@ -32,7 +32,7 @@ export function createNumberLiteral(
 export function updateNumberLiteral(
     original: NumberLiteral,
     value: number
-) {
+): NumberLiteral {
     if (isSameNativeObject(value.toString(), original.str)) {
         return original
     }

package/build/libarkts-copy/src/arkts-api/node-utilities/ObjectExpression.ts

@@ -20,7 +20,7 @@ import { nodeType, updateNodeByNode } from "../utilities/private"
 export function updateObjectExpression(
     original: ObjectExpression,
     properties: readonly Expression[]
-) {
+): ObjectExpression {
     if (isSameNativeObject(properties, original.properties)){
         return original
     }

package/build/libarkts-copy/src/arkts-api/node-utilities/Program.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 { ExternalSource } from "../peers/ExternalSource"
+import { acceptNativeObjectArrayResult } from "../utilities/private"
+import { KNativePointer } from "@koalaui/interop"
+import { global } from "../static/global"
+import { Program } from "../../generated"
+
+export function programGetExternalSources(program: Program, context: KNativePointer = global.context): ExternalSource[] {
+    return acceptNativeObjectArrayResult<ExternalSource>(
+        global.es2panda._ProgramExternalSources(context, program.peer),
+        (instance: KNativePointer) => new ExternalSource(instance)
+    )
+}
+
+export function dumpProgramInfo(program: Program) {
+    console.log(`Program info:`)
+    console.log(`\tAbsoluteName:          ${program.absoluteName}`)
+    console.log(`\tFileName:              ${program.fileName}`)
+    console.log(`\tFileNameWithExtension: ${program.fileNameWithExtension}`)
+    console.log(`\tModuleName:            ${program.moduleName}`)
+    console.log(`\tModulePrefix:          ${program.modulePrefix}`)
+    console.log(`\tRelativeFilePath:      ${program.relativeFilePath}`)
+    console.log(`\tResolvedFilePath:      ${program.resolvedFilePath}`)
+    console.log(`\tSourceFileFolder:      ${program.sourceFileFolder}`)
+    console.log(`\tSourceFilePath:        ${program.sourceFilePath}`)
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ReturnStatement.ts

@@ -0,0 +1,27 @@
+/*
+ * 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, ReturnStatement } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateReturnStatement(original: ReturnStatement, argument?: Expression): ReturnStatement {
+    if (isSameNativeObject(argument, original.argument)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ReturnStatement.update1ReturnStatement, attachModifiers);
+    return update(original, argument);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/StringLiteral.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { StringLiteral } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateStringLiteral(original: StringLiteral, str: string): StringLiteral {
+    if (isSameNativeObject(str, original.str)) {
+        return original;
+    }
+
+    const update = updateThenAttach(StringLiteral.update1StringLiteral, attachModifiers);
+    return update(original, str);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/SuperExpression.ts

@@ -0,0 +1,24 @@
+/*
+ * 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 { SuperExpression } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateSuperExpression(original: SuperExpression): SuperExpression {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(SuperExpression.updateSuperExpression, attachModifiers);
+    return update(original);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/TSAsExpression.ts

@@ -0,0 +1,36 @@
+/*
+ * 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, TSAsExpression, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSAsExpression(
+    original: TSAsExpression,
+    expression: Expression | undefined,
+    typeAnnotation: TypeNode | undefined,
+    isConst: boolean
+): TSAsExpression {
+    if (
+        isSameNativeObject(expression, original.expr) &&
+        isSameNativeObject(typeAnnotation, original.typeAnnotation) &&
+        isSameNativeObject(isConst, original.isConst)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSAsExpression.updateTSAsExpression, attachModifiers);
+    return update(original, expression, typeAnnotation, isConst);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/TSClassImplements.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, TSClassImplements, TSTypeParameterInstantiation } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSClassImplements(
+    original: TSClassImplements,
+    expression?: Expression,
+    typeParameters?: TSTypeParameterInstantiation
+): TSClassImplements {
+    if (isSameNativeObject(expression, original.expr) && isSameNativeObject(typeParameters, original.typeParameters)) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSClassImplements.updateTSClassImplements, attachModifiers);
+    return update(original, expression, typeParameters);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/TSInterfaceBody.ts

@@ -0,0 +1,28 @@
+/*
+ * 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 { TSInterfaceBody } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { AstNode } from '../peers/AstNode';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSInterfaceBody(original: TSInterfaceBody, body: readonly AstNode[]): TSInterfaceBody {
+    if (isSameNativeObject(body, original.body)) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSInterfaceBody.updateTSInterfaceBody, attachModifiers);
+    return update(original, body);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/TSInterfaceDeclaration.ts

@@ -14,21 +14,38 @@
  */
 
 import {
-    ETSFunctionType,
-    Expression,
-    FunctionSignature,
-    MethodDefinition,
     TSInterfaceDeclaration, TSInterfaceHeritage
 } from "../../generated"
 import {
-    Es2pandaMethodDefinitionKind,
     Es2pandaModifierFlags,
-    Es2pandaScriptFunctionFlags
 } from "../../generated/Es2pandaEnums"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import { updateNodeByNode } from "../utilities/private"
 import { AstNode } from "../peers/AstNode"
 
+export function createTSInterfaceDeclaration(
+    _extends: readonly TSInterfaceHeritage[],
+    id: AstNode | undefined,
+    typeParams: AstNode | undefined,
+    body: AstNode | undefined,
+    isStatic: boolean,
+    isExternal: boolean,
+    modifierFlags?: Es2pandaModifierFlags,
+): TSInterfaceDeclaration {
+    const res = TSInterfaceDeclaration.createTSInterfaceDeclaration(
+        _extends,
+        id,
+        typeParams,
+        body,
+        isStatic,
+        isExternal
+    )
+    if (modifierFlags) {
+        res.modifierFlags = modifierFlags
+    }
+    return res
+}
+
 export function updateTSInterfaceDeclaration(
     original: TSInterfaceDeclaration,
     _extends: readonly TSInterfaceHeritage[],
@@ -36,25 +53,28 @@ export function updateTSInterfaceDeclaration(
     typeParams: AstNode | undefined,
     body: AstNode | undefined,
     isStatic: boolean,
-    isExternal: boolean
-) {
+    isExternal: boolean,
+    modifierFlags?: Es2pandaModifierFlags,
+): TSInterfaceDeclaration {
     if (isSameNativeObject(_extends, original.extends)
         && isSameNativeObject(id, original.id)
         && isSameNativeObject(typeParams, original.typeParams)
         && isSameNativeObject(body, original.body)
         && isSameNativeObject(isStatic, original.isStatic)
         && isSameNativeObject(isExternal, original.isFromExternal)
+        && isSameNativeObject(modifierFlags, original.modifierFlags)
     ) {
         return original
     }
     return updateNodeByNode(
-        TSInterfaceDeclaration.createTSInterfaceDeclaration(
+        createTSInterfaceDeclaration(
             _extends,
             id,
             typeParams,
             body,
             isStatic,
-            isExternal
+            isExternal,
+            modifierFlags,
         ),
         original
     )

package/build/libarkts-copy/src/arkts-api/node-utilities/TSNonNullExpression.ts

@@ -0,0 +1,27 @@
+/*
+ * 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, TSNonNullExpression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSNonNullExpression(original: TSNonNullExpression, expr?: Expression): TSNonNullExpression {
+    if (isSameNativeObject(expr, original.expr)) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSNonNullExpression.updateTSNonNullExpression, attachModifiers);
+    return update(original, expr);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/TSTypeAliasDeclaration.ts

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+import { Es2pandaModifierFlags } from ".."
 import { AnnotationUsage, Identifier, TSTypeAliasDeclaration, TSTypeParameterDeclaration, TypeNode } from "../../generated"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import { updateNodeByNode } from "../utilities/private"
@@ -21,7 +22,8 @@ export function createTSTypeAliasDeclaration(
     id?: Identifier,
     typeParams?: TSTypeParameterDeclaration,
     typeAnnotation?: TypeNode,
-    annotations?: readonly AnnotationUsage[] 
+    annotations?: readonly AnnotationUsage[],
+    modifiers?: Es2pandaModifierFlags
 ): TSTypeAliasDeclaration {
     const res = TSTypeAliasDeclaration.createTSTypeAliasDeclaration(
         id,
@@ -31,6 +33,9 @@ export function createTSTypeAliasDeclaration(
     if (annotations) {
         res.setAnnotations(annotations)
     }
+    if (modifiers) {
+        res.modifierFlags = modifiers
+    }
     return res
 }
 
@@ -39,12 +44,14 @@ export function updateTSTypeAliasDeclaration(
     id?: Identifier,
     typeParams?: TSTypeParameterDeclaration,
     typeAnnotation?: TypeNode,
-    annotations?: readonly AnnotationUsage[] 
+    annotations?: readonly AnnotationUsage[],
+    modifiers?: Es2pandaModifierFlags
 ): TSTypeAliasDeclaration {
     if (isSameNativeObject(id, original.id)
         && isSameNativeObject(typeParams, original.typeParams)
         && isSameNativeObject(typeAnnotation, original.typeAnnotation)
         && isSameNativeObject(annotations, original.annotations)
+        && isSameNativeObject(modifiers, original.modifierFlags)
     ) {
         return original
     }
@@ -54,6 +61,7 @@ export function updateTSTypeAliasDeclaration(
             typeParams,
             typeAnnotation,
             annotations,
+            modifiers
         ),
         original,
     )

package/build/libarkts-copy/src/arkts-api/node-utilities/TSTypeParameter.ts

@@ -24,7 +24,7 @@ export function updateTSTypeParameter(
     constraint: TypeNode | undefined,
     defaultType: TypeNode | undefined,
     flags: Es2pandaModifierFlags
-) {
+): TSTypeParameter {
     if (isSameNativeObject(name, original.name)
         && isSameNativeObject(constraint, original.constraint)
         && isSameNativeObject(defaultType, original.defaultType)

package/build/libarkts-copy/src/arkts-api/node-utilities/TSTypeParameterDeclaration.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 { TSTypeParameter, TSTypeParameterDeclaration } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSTypeParameterDeclaration(
+    original: TSTypeParameterDeclaration,
+    params: readonly TSTypeParameter[],
+    requiredParams: number
+): TSTypeParameterDeclaration {
+    if (isSameNativeObject(params, original.params) && isSameNativeObject(requiredParams, original.requiredParams)) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSTypeParameterDeclaration.updateTSTypeParameterDeclaration, attachModifiers);
+    return update(original, params, requiredParams);
+}