@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

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

@@ -31,7 +31,7 @@ export function createTSInterfaceDeclaration(
     isStatic: boolean,
     isExternal: boolean,
     modifierFlags?: Es2pandaModifierFlags,
-) {
+): TSInterfaceDeclaration {
     const res = TSInterfaceDeclaration.createTSInterfaceDeclaration(
         _extends,
         id,
@@ -55,7 +55,7 @@ export function updateTSInterfaceDeclaration(
     isStatic: boolean,
     isExternal: boolean,
     modifierFlags?: Es2pandaModifierFlags,
-) {
+): TSInterfaceDeclaration {
     if (isSameNativeObject(_extends, original.extends)
         && isSameNativeObject(id, original.id)
         && isSameNativeObject(typeParams, original.typeParams)

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/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);
+}

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

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

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

@@ -22,7 +22,7 @@ export function updateETSTypeReferencePart(
     name?: Expression,
     typeParams?: TSTypeParameterInstantiation,
     prev?: ETSTypeReferencePart
-) {
+): ETSTypeReferencePart {
     if (isSameNativeObject(name, original.name)
         && isSameNativeObject(typeParams, original.typeParams)
         && isSameNativeObject(prev, original.previous)

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

@@ -0,0 +1,35 @@
+/*
+ * 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 { TemplateLiteral, TemplateElement, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTemplateLiteral(
+    original: TemplateLiteral,
+    quasis: readonly TemplateElement[],
+    expressions: readonly Expression[],
+    multilineString: string
+): TemplateLiteral {
+    if (
+        isSameNativeObject(quasis, original.quasis) &&
+        isSameNativeObject(expressions, original.expressions)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(TemplateLiteral.updateTemplateLiteral, attachModifiers);
+    return update(original, quasis, expressions, multilineString);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ThisExpression.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 { ThisExpression } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateThisExpression(original: ThisExpression): ThisExpression {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(ThisExpression.updateThisExpression, attachModifiers);
+    return update(original);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/UndefinedLiteral.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 { UndefinedLiteral } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateUndefinedLiteral(original: UndefinedLiteral): UndefinedLiteral {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(UndefinedLiteral.updateUndefinedLiteral, attachModifiers);
+    return update(original);
+}

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

@@ -40,7 +40,7 @@ export function updateVariableDeclaration(
     kind: Es2pandaVariableDeclarationKind,
     declarators: readonly VariableDeclarator[],
     annotations?: readonly AnnotationUsage[]
-) {
+): VariableDeclaration {
     if (isSameNativeObject(kind, original.kind)
         && isSameNativeObject(declarators, original.declarators)
         && isSameNativeObject(annotations, original.annotations)

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

@@ -23,7 +23,7 @@ export function updateVariableDeclarator(
     flag: Es2pandaVariableDeclaratorFlag,
     ident?: Expression,
     init?: Expression
-) {
+): VariableDeclarator {
     if (isSameNativeObject(flag, original.flag)
         && isSameNativeObject(ident, original.id)
         && isSameNativeObject(init, original.init)

package/build/libarkts-copy/src/arkts-api/peers/ArktsObject.ts

@@ -20,7 +20,9 @@ export abstract class ArktsObject {
         this.peer = peer
     }
 
-    readonly peer: KNativePointer
+    peer: KNativePointer
+
+    public onUpdate(node: ArktsObject) {}
 }
 
 export function isSameNativeObject<T extends ArktsObject | number | string | boolean | undefined>(

package/build/libarkts-copy/src/arkts-api/peers/AstNode.ts

@@ -19,15 +19,18 @@ import { allFlags, unpackNodeArray, unpackNonNullableNode, unpackString } from "
 import { throwError } from "../../utils"
 import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { ArktsObject } from "./ArktsObject"
+import { SourcePosition } from "./SourcePosition"
+import { NodeCache } from "../node-cache"
 
 export abstract class AstNode extends ArktsObject {
     protected constructor(peer: KNativePointer) {
-        global.profiler.createdNodes ++
+        global.profiler.nodeCreated()
         if (isNullPtr(peer)) {
             throwError(`attempted to create AstNode from nullptr`)
         }
         super(peer)
         this.updateChildren()
+        NodeCache.addToCache(peer, this)
     }
 
     public get originalPeer(): KNativePointer {
@@ -56,11 +59,12 @@ export abstract class AstNode extends ArktsObject {
         )
     }
 
-    public updateChildren(): void {
+    public updateChildren(): this {
         if (this.peer === nullptr) {
             throwError('updateChildren called on NULLPTR')
         }
         global.es2panda._AstNodeUpdateChildren(global.context, this.peer)
+        return this
     }
 
     public updateModifiers(modifierFlags: KInt | undefined): this {
@@ -95,20 +99,37 @@ export abstract class AstNode extends ArktsObject {
         return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer))
     }
 
+    // public clone(): this {
+    //     return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer));
+    // }
+
+    // public get parent(): AstNode {
+    //     const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
+    //     if (parent === nullptr) {
+    //         throwError(`no parent`)
+    //     }
+    //     return unpackNonNullableNode(parent)
+    // }
+
+    // public set parent(node: AstNode) {
+    //     global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
+    // }
+
     public clone(): this {
-        return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer));
+        const clonedNode = unpackNonNullableNode(
+            global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent?.peer ?? nullptr)
+        );
+        clonedNode.parent = undefined;
+        return clonedNode as this;
     }
-
-    public get parent(): AstNode {
-        const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
-        if (parent === nullptr) {
-            throwError(`no parent`)
-        }
-        return unpackNonNullableNode(parent)
+    
+    public get parent(): AstNode | undefined {
+        const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer);
+        return unpackNonNullableNode(parent);
     }
 
-    public set parent(node: AstNode) {
-        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
+    public set parent(node: AstNode | undefined) {
+        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node?.peer ?? nullptr);
     }
 
     public get modifierFlags(): Es2pandaModifierFlags {
@@ -119,4 +140,46 @@ export abstract class AstNode extends ArktsObject {
         global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags)
         global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE)
     }
+    
+    /** @deprecated Use {@link modifierFlags} instead */
+    public get modifiers(): KInt {
+        return this.modifierFlags
+    }
+
+    /** @deprecated Use {@link modifierFlags} instead */
+    public set modifiers(flags: KInt | undefined) {
+        this.modifierFlags = flags
+    }
+
+    public override onUpdate(node: AstNode): void {
+        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, this.originalPeer)
+    }
+
+    public get isExport(): boolean {
+        return global.generatedEs2panda._AstNodeIsExportedConst(global.context, this.peer);
+    }
+
+    public get isDefaultExport(): boolean {
+        return global.generatedEs2panda._AstNodeIsDefaultExportedConst(global.context, this.peer);
+    }
+
+    public get isStatic(): boolean {
+        return global.generatedEs2panda._AstNodeIsStaticConst(global.context, this.peer);
+    }
+    
+    public get startPosition(): SourcePosition {
+        return new SourcePosition(global.generatedEs2panda._AstNodeStartConst(global.context, this.peer));
+    }
+
+    public set startPosition(start: SourcePosition) {
+        global.generatedEs2panda._AstNodeSetStart(global.context, this.peer, start.peer);
+    }
+
+    public get endPosition(): SourcePosition {
+        return new SourcePosition(global.generatedEs2panda._AstNodeEndConst(global.context, this.peer));
+    }
+
+    public set endPosition(end: SourcePosition) {
+        global.generatedEs2panda._AstNodeSetEnd(global.context, this.peer, end.peer);
+    }
 }

package/build/libarkts-copy/src/arkts-api/peers/Config.ts

@@ -16,7 +16,7 @@
 import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { passStringArray } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
+import { KNativePointer, nullptr } from "@koalaui/interop"
 
 export class Config extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -48,5 +48,12 @@ export class Config extends ArktsObject {
         )
     }
 
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyConfig(this.peer)
+            this.peer = nullptr
+        }
+    }
+
     readonly path: string
 }