@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

package/build/libarkts-copy/src/arkts-api/CompileWithCache.ts

@@ -0,0 +1,193 @@
+/*
+ * 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 { Config } from "./peers/Config"
+import { CompilationOptions, PluginContextImpl, ProgramTransformer } from "./plugins"
+import { findStdlib, proceedToState, recheckContext } from "./utilities/public"
+import { global } from "./static/global"
+import { passString, passStringArray } from "./utilities/private"
+import { Context } from "./peers/Context"
+import { Es2pandaContextState } from "../generated/Es2pandaEnums"
+import { Program } from "../generated"
+import { runTransformerOnProgram } from "../plugin-utils"
+import { ProgramProvider } from "./ProgramProvider"
+import { Options } from "./peers/Options"
+
+export interface ProgramInfo {
+    /**
+     * Input to compile (absolute file path)
+     */
+    absoluteName: string
+    /**
+     * Location of output (undefined for external sources)
+     */
+    output: string | undefined
+}
+
+export function getProgramsForPluginApplication(
+    programs: ProgramInfo[],
+) {
+    const programsForCodeGeneration = programs
+        .filter(it => it.output != undefined)
+        .map(it => it.absoluteName)
+    // Generally, it would be ok to return just the list above,
+    // but for experimental purpose let's filter programs that
+    // are mentioned as both codegeneration and caching
+    const programsForCaching = new Set(
+        programs
+        .filter(it => it.output == undefined)
+        .map(it => it.absoluteName)
+    )
+    return programsForCodeGeneration.filter(it => !programsForCaching.has(it))
+}
+
+export function compileWithCache(
+    configPath: string,
+    orderedPrograms: ProgramInfo[],
+    parsedPlugins: ProgramTransformer[] | undefined,
+    checkedPlugins: ProgramTransformer[] | undefined,
+) {
+    if (orderedPrograms.length == 0) {
+        console.log("No files to compile")
+        return
+    }
+    const globalConfig = Config.create(
+        [
+            '_', '--arktsconfig', configPath, '--extension', 'ets', '--stdlib', findStdlib(),
+            orderedPrograms[0].absoluteName // Putting some file here to avoid "Fatal error: Unresolved module name"
+        ]
+    )
+    console.log(orderedPrograms)
+    const globalContext = global.es2panda._CreateGlobalContext(
+        globalConfig.peer,
+        passStringArray(orderedPrograms.map(it => it.absoluteName)),
+        orderedPrograms.length,
+        false
+    )
+
+    const programsForPluginApplication = getProgramsForPluginApplication(
+        orderedPrograms
+    )
+
+    orderedPrograms.forEach((it) => {
+        console.log(">>>", "considering", it.absoluteName)
+        const args = ['_', '--arktsconfig', configPath, '--extension', 'ets', '--stdlib', findStdlib()]
+        if (it.output) {
+            args.push('--output', it.output, it.absoluteName)
+        }
+        const config = Config.create(
+            args
+        )
+        const isExternalProgram = (it.output == undefined)
+        const context = global.es2panda._CreateCacheContextFromFile(
+            config.peer,
+            passString(it.absoluteName),
+            globalContext,
+            isExternalProgram,
+        )
+
+        global.config = config.peer
+        global.compilerContext = new Context(context)
+        const options = Options.createOptions(new Config(global.config))
+        global.arktsconfig = options.getArkTsConfig()
+
+        function applyPlugins(plugins: ProgramTransformer[] | undefined, state: Es2pandaContextState) {
+            plugins?.forEach(plugin => {
+                const program = new Program(global.es2panda._ContextProgram(context))
+                const provider = new ProgramProvider(program)
+                let currentProgram = provider.next()
+                let isFirstProgram = true
+                while (currentProgram) {
+                    if (
+                        (!isExternalProgram && programsForPluginApplication.includes(currentProgram.absoluteName)) ||
+                        (isExternalProgram && currentProgram.absoluteName == it.absoluteName)
+                     ) {
+                        const options: CompilationOptions = {
+                            isMainProgram: isFirstProgram,
+                            stage: state,
+                            restart: false,
+                        }
+                        runTransformerOnProgram(
+                            currentProgram,
+                            options,
+                            plugin,
+                            new PluginContextImpl(),
+                        )
+                    }
+                    currentProgram = provider.next()
+                    isFirstProgram = false
+                }
+                if (state == Es2pandaContextState.ES2PANDA_STATE_CHECKED) {
+                    recheckContext(context)
+                }
+            })
+        }
+
+        function proceedToParsed() {
+            proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        }
+
+        function applyParsedPlugins() {
+            applyPlugins(parsedPlugins, Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        }
+
+        function proceedToChecked() {
+            proceedToState(Es2pandaContextState.ES2PANDA_STATE_CHECKED)
+        }
+
+        function applyCheckedPlugins() {
+            applyPlugins(checkedPlugins, Es2pandaContextState.ES2PANDA_STATE_CHECKED)
+        }
+
+        function proceedToFinalState() {
+            if (isExternalProgram) {
+                proceedToState(Es2pandaContextState.ES2PANDA_STATE_LOWERED)
+            } else {
+                proceedToState(Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED)
+            }
+        }
+
+        function cleanup() {
+            global.es2panda._DestroyContext(
+                context
+            )
+            global.es2panda._DestroyConfig(
+                config.peer
+            )
+        }
+
+        const operations = [
+            proceedToParsed,
+            applyParsedPlugins,
+            proceedToChecked,
+            applyCheckedPlugins,
+            proceedToFinalState,
+            cleanup,
+        ]
+
+        operations.forEach(operation => {
+            console.log('>>>', operation.name)
+            operation()
+            console.log('>>>', operation.name, 'OK')
+        })
+    })
+
+    global.es2panda._DestroyGlobalContext(
+        globalContext
+    )
+    global.es2panda._DestroyConfig(
+        globalConfig.peer
+    )
+}

package/build/libarkts-copy/src/arkts-api/ImportStorage.ts

@@ -0,0 +1,78 @@
+/*
+ * 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 { KNativePointer } from "@koalaui/interop"
+import { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from "../generated"
+import { updateETSModuleByStatements } from "./utilities/public"
+import { passNode, passNodeArray, unpackNonNullableNode } from "./utilities/private"
+import { global } from "./static/global"
+import { Es2pandaImportFlags, Es2pandaImportKinds } from "../generated/Es2pandaEnums"
+
+export class ImportStorage {
+    // TODO: migrate to wrappers instead of pointers
+    private imports: Set<KNativePointer> = new Set<KNativePointer>()
+    private importSources: Set<string | undefined> = new Set<string | undefined>()
+
+    constructor(private program: Program, private isParserStage: boolean) {
+        for (const statement of program.ast.statements) {
+            if (isETSImportDeclaration(statement)) {
+                this.imports.add(statement.peer)
+                if (!isParserStage) {
+                    // TODO: is source non nullable?
+                    this.importSources.add(statement.source?.str)
+                }
+            }
+        }
+    }
+
+    update() {
+        // Save current statements
+        const statements = this.program.ast.statements
+
+        // Update parser information
+        const newStatements: Statement[] = []
+        for (const statement of statements) {
+            if (isETSImportDeclaration(statement) && !this.imports.has(statement.peer)) {
+                if (!this.isParserStage && !this.importSources.has(statement.source?.str)) {
+                    console.warn("Attempt to insert import from new source after parsed stage:")
+                    console.warn(statement.dumpSrc())
+                }
+
+                const importDeclaration = unpackNonNullableNode<ImportDeclaration>(
+                    // Note: this call is important, we cannot just pass "statement" to "InsertETSImportDeclarationAndParse"
+                    global.es2panda._ETSParserBuildImportDeclaration(
+                        global.context,
+                        Es2pandaImportKinds.IMPORT_KINDS_ALL, // TODO: do we use IMPORT_KINDS_TYPES?
+                        passNodeArray(statement.specifiers),
+                        statement.specifiers.length,
+                        passNode(statement.source),
+                        this.program.peer,
+                        Es2pandaImportFlags.IMPORT_FLAGS_NONE, // TODO: where to get it?
+                    )
+                )
+                global.es2panda._InsertETSImportDeclarationAndParse(global.context, this.program.peer, importDeclaration.peer)
+                newStatements.push(importDeclaration)
+            } else {
+                newStatements.push(statement)
+            }
+        }
+
+        // Drop import statements generated by compiler in the beginning of the ETSModule
+        updateETSModuleByStatements(
+            this.program.ast as ETSModule,
+            newStatements,
+        )
+    }
+}

package/build/libarkts-copy/src/arkts-api/InferVoidReturnType.ts

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2022-2023 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 { factory } from "./factory/nodeFactory"
+import { isReturnStatement, isScriptFunction, ScriptFunction } from "../generated"
+import { AbstractVisitor } from "./AbstractVisitor"
+import { AstNode } from "./peers/AstNode"
+import { Es2pandaPrimitiveType, Es2pandaScriptFunctionFlags } from "src/generated/Es2pandaEnums"
+
+interface IsScriptFunctionRoot {
+    isScriptFunctionRoot: boolean
+}
+
+// TODO: this is to workaround compiler not beeing able to infer return type on recheck
+class CheckReturns extends AbstractVisitor {
+    visitor(node: AstNode, options?: IsScriptFunctionRoot): AstNode {
+        if (isReturnStatement(node) && node.argument !== undefined) {
+            this.seenNonVoidReturn = true
+        }
+        if (isScriptFunction(node) && !options?.isScriptFunctionRoot) {
+            return node
+        }
+        return this.visitEachChild(node)
+    }
+
+    seenNonVoidReturn: boolean = false
+    static instance?: CheckReturns
+}
+
+// This function checks that it is possible to infer return type of script function as void
+function checkReturns(node: AstNode): boolean {
+    if (!CheckReturns.instance) {
+        CheckReturns.instance = new CheckReturns()
+    }
+    CheckReturns.instance.seenNonVoidReturn = false
+    CheckReturns.instance.visitor(node, { isScriptFunctionRoot: true })
+    return CheckReturns.instance.seenNonVoidReturn == false
+}
+
+class InferVoidReturnType extends AbstractVisitor {
+    visitor(node: AstNode): AstNode {
+        const result = this.visitEachChild(node)
+        if (isScriptFunction(result) &&
+            result.returnTypeAnnotation === undefined &&
+            !result.isConstructor && // constructors should not have return type
+            (result.flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_SETTER) == 0 // setters should not return void
+        ) {
+            const isVoid = checkReturns(result)
+            if (isVoid) {
+                return factory.updateScriptFunction(
+                    result,
+                    result.body,
+                    result.typeParams,
+                    result.params,
+                    factory.createETSPrimitiveType(
+                        Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID,
+                    ),
+                    result.hasReceiver,
+                    result.flags,
+                    result.modifierFlags,
+                    result.id,
+                    result.annotations,
+                )
+            }
+        }
+        return result
+    }
+
+    static instance?: InferVoidReturnType
+}
+
+export function inferVoidReturnType(node: AstNode) {
+    if (!InferVoidReturnType.instance) {
+        InferVoidReturnType.instance = new InferVoidReturnType()
+    }
+    InferVoidReturnType.instance.visitor(node)
+}

package/build/libarkts-copy/src/arkts-api/ProgramProvider.ts

@@ -0,0 +1,50 @@
+/*
+ * 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 { KNativePointer } from "@koalaui/interop"
+import { defaultFilter, listPrograms } from "./plugins"
+import { Program } from "../generated"
+
+export class ProgramProvider {
+    // TODO: migrate to wrappers instead of pointers
+    seenPrograms: Set<KNativePointer> = new Set<KNativePointer>()
+    queue: Program[] = []
+
+    constructor(private mainProgram: Program, private readonly filter: (name: string) => boolean = defaultFilter) {
+        this.seenPrograms.add(mainProgram.peer)
+        this.queue = [mainProgram]
+    }
+
+    updateQueue() {
+        const listed = listPrograms(this.mainProgram, this.filter)
+        for (const program of listed) {
+            if (!this.seenPrograms.has(program.peer)) {
+                this.seenPrograms.add(program.peer)
+                this.queue.push(program)
+            }
+        }
+    }
+
+    next(): Program | undefined {
+        if (this.queue.length == 0) {
+            this.updateQueue()
+            if (this.queue.length == 0) {
+                // console.log("PROGRAMS:", this.seenPrograms.size)
+                return undefined
+            }
+        }
+        return this.queue.shift()
+    }
+}

package/build/libarkts-copy/src/arkts-api/SetBaseOverloads.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022-2023 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 { factory } from "./factory/nodeFactory"
+import { isMethodDefinition } from "../generated"
+import { AbstractVisitor } from "./AbstractVisitor"
+import { AstNode } from "./peers/AstNode"
+
+export class SetBaseOverloads extends AbstractVisitor {
+    visitor(node: AstNode): AstNode {
+        if (isMethodDefinition(node)) {
+            const baseOverloadMethod = node
+            return factory.updateMethodDefinition(
+                node,
+                node.kind,
+                node.key,
+                node.value,
+                node.modifierFlags,
+                node.isComputed,
+                node.overloads.map((it) => {
+                    it.setBaseOverloadMethod(baseOverloadMethod)
+                    return it
+                })
+            )
+        }
+        return this.visitEachChild(node)
+    }
+}
+
+export function setBaseOverloads(node: AstNode) {
+    new SetBaseOverloads().visitor(node)
+}

package/build/libarkts-copy/src/arkts-api/class-by-peer.ts

@@ -18,8 +18,7 @@ import { throwError } from "../utils"
 import { global } from "./static/global"
 import { KNativePointer, nullptr } from "@koalaui/interop"
 import { AstNode } from "./peers/AstNode"
-import { factory } from "@koalaui/ets-tsc"
-import { unpackString } from "./utilities/private"
+import { NodeCache } from "./node-cache"
 
 export const nodeByType = new Map<Es2pandaAstNodeType, (peer: KNativePointer) => AstNode>([])
 
@@ -29,5 +28,5 @@ export function classByPeer<T extends AstNode>(peer: KNativePointer): T {
     }
     const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
     const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`)
-    return create(peer) as T
+    return NodeCache.cached(peer, create)
 }

package/build/libarkts-copy/src/arkts-api/factory/nodeFactory.ts

@@ -15,16 +15,15 @@
 
 import {
     ClassDefinition,
-    ClassProperty,
+    ETSImportDeclaration,
     ETSStructDeclaration,
+    ETSTuple,
     ETSTypeReferencePart,
     MemberExpression,
+    ObjectExpression,
     TryStatement,
-    TSInterfaceDeclaration,
     TSTypeParameter,
     VariableDeclarator,
-    ObjectExpression,
-    ETSTuple,
 } from "../../generated"
 import { factory as generatedFactory } from "../../generated/factory"
 import { createScriptFunction, updateScriptFunction } from "../node-utilities/ScriptFunction"
@@ -34,14 +33,14 @@ import { updateMemberExpression } from "../node-utilities/MemberExpression"
 import { createETSParameterExpression, updateETSParameterExpression } from "../node-utilities/ETSParameterExpression"
 import { updateTSTypeParameter } from "../node-utilities/TSTypeParameter"
 import { updateETSTypeReferencePart } from "../node-utilities/TSTypeReferencePart"
-import { createETSImportDeclaration, updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration"
+import { updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration"
 import { updateVariableDeclarator } from "../node-utilities/VariableDeclarator"
 import { updateClassDefinition } from "../node-utilities/ClassDefinition"
 import { updateETSStructDeclaration } from "../node-utilities/ETSStructDeclaration"
-import { updateClassProperty } from "../node-utilities/ClassProperty"
+import { createClassProperty, updateClassProperty } from "../node-utilities/ClassProperty"
 import { createETSFunctionType, updateETSFunctionType } from "../node-utilities/ETSFunctionType"
 import { createMethodDefinition, updateMethodDefinition } from "../node-utilities/MethodDefinition"
-import { updateTSInterfaceDeclaration } from "../node-utilities/TSInterfaceDeclaration"
+import { createTSInterfaceDeclaration, updateTSInterfaceDeclaration } from "../node-utilities/TSInterfaceDeclaration"
 import { createArrowFunctionExpression, updateArrowFunctionExpression } from "../node-utilities/ArrowFunctionExpression"
 import { updateTryStatement } from "../node-utilities/TryStatement"
 import { createVariableDeclaration, updateVariableDeclaration } from "../node-utilities/VariableDeclaration"
@@ -50,6 +49,33 @@ import { updateObjectExpression } from "../node-utilities/ObjectExpression"
 import { updateETSTuple } from "../node-utilities/ETSTuple"
 import { createArrayExpression, updateArrayExpression } from "../node-utilities/ArrayExpression"
 import { createTSTypeAliasDeclaration, updateTSTypeAliasDeclaration } from "../node-utilities/TSTypeAliasDeclaration"
+import { createClassDeclaration, updateClassDeclaration } from "../node-utilities/ClassDeclaration"
+import { createBlockStatement, updateBlockStatement } from "../node-utilities/BlockStatement"
+import { updateAnnotationDeclaration } from "../node-utilities/AnnotationDeclaration"
+import { updateAnnotationUsage, update1AnnotationUsage } from "../node-utilities/AnnotationUsage"
+import { updateBinaryExpression } from "../node-utilities/BinaryExpression"
+import { updateBlockExpression } from "../node-utilities/BlockExpression"
+import { updateChainExpression } from "../node-utilities/ChainExpression"
+import { updateConditionalExpression } from "../node-utilities/ConditionalExpression"
+import { updateETSPrimitiveType } from "../node-utilities/ETSPrimitiveType"
+import { updateETSTypeReference } from "../node-utilities/ETSTypeReference"
+import { updateETSUndefinedType } from "../node-utilities/ETSUndefinedType"
+import { updateETSUnionType } from "../node-utilities/ETSUnionType"
+import { updateIdentifier } from "../node-utilities/Identifier"
+import { updateImportSpecifier } from "../node-utilities/ImportSpecifier"
+import { updateNullLiteral } from "../node-utilities/NullLiteral"
+import { updateReturnStatement } from "../node-utilities/ReturnStatement"
+import { updateStringLiteral } from "../node-utilities/StringLiteral"
+import { updateSuperExpression } from "../node-utilities/SuperExpression"
+import { updateTSAsExpression } from "../node-utilities/TSAsExpression"
+import { updateTSClassImplements } from "../node-utilities/TSClassImplements"
+import { updateTSInterfaceBody } from "../node-utilities/TSInterfaceBody"
+import { updateTSNonNullExpression } from "../node-utilities/TSNonNullExpression"
+import { updateTSTypeParameterDeclaration } from "../node-utilities/TSTypeParameterDeclaration"
+import { updateTSTypeParameterInstantiation } from "../node-utilities/TSTypeParameterInstantiation"
+import { updateTemplateLiteral } from "../node-utilities/TemplateLiteral"
+import { updateThisExpression } from "../node-utilities/ThisExpression"
+import { updateUndefinedLiteral } from "../node-utilities/UndefinedLiteral"
 
 export const factory = {
     ...generatedFactory,
@@ -75,7 +101,7 @@ export const factory = {
     createETSTypeReferencePart: ETSTypeReferencePart.createETSTypeReferencePart,
     updateETSTypeReferencePart,
 
-    createETSImportDeclaration,
+    createETSImportDeclaration: ETSImportDeclaration.createETSImportDeclaration,
     updateETSImportDeclaration,
 
     createVariableDeclarator: VariableDeclarator.create1VariableDeclarator,
@@ -90,7 +116,10 @@ export const factory = {
     createClassDefinition: ClassDefinition.createClassDefinition,
     updateClassDefinition,
 
-    createClassProperty: ClassProperty.createClassProperty,
+    createClassDeclaration,
+    updateClassDeclaration,
+
+    createClassProperty,
     updateClassProperty,
 
     createETSFunctionType,
@@ -99,7 +128,7 @@ export const factory = {
     createMethodDefinition,
     updateMethodDefinition,
 
-    createInterfaceDeclaration: TSInterfaceDeclaration.createTSInterfaceDeclaration,
+    createInterfaceDeclaration: createTSInterfaceDeclaration,
     updateInterfaceDeclaration: updateTSInterfaceDeclaration,
 
     createArrowFunctionExpression,
@@ -122,4 +151,58 @@ export const factory = {
 
     createTSTypeAliasDeclaration,
     updateTSTypeAliasDeclaration,
+
+    createBlockStatement,
+    updateBlockStatement,
+
+    updateAnnotationDeclaration,
+
+    updateAnnotationUsage,
+    update1AnnotationUsage,
+
+    updateBinaryExpression,
+
+    updateBlockExpression,
+
+    updateChainExpression,
+
+    updateConditionalExpression,
+
+    updateETSPrimitiveType,
+
+    updateETSTypeReference,
+
+    updateETSUndefinedType,
+
+    updateETSUnionType,
+
+    updateIdentifier,
+
+    updateImportSpecifier,
+
+    updateNullLiteral,
+
+    updateReturnStatement,
+
+    updateStringLiteral,
+
+    updateSuperExpression,
+
+    updateTSAsExpression,
+
+    updateTSClassImplements,
+
+    updateInterfaceBody : updateTSInterfaceBody,
+
+    updateTSNonNullExpression,
+
+    updateTSTypeParameterDeclaration,
+
+    updateTSTypeParameterInstantiation,
+
+    updateTemplateLiteral,
+
+    updateThisExpression,
+
+    updateUndefinedLiteral
 }

package/build/libarkts-copy/src/arkts-api/index.ts

@@ -21,10 +21,22 @@ export * from "./utilities/public"
 export * from "./factory/nodeFactory"
 export * from "./visitor"
 export * from "./AbstractVisitor"
+export * from "./ChainExpressionFilter"
+export * from "./CheckedBackFilter"
+export * from "./SetBaseOverloads"
+export * from "./plugins"
+export * from "./ImportStorage"
+export * from "./InferVoidReturnType"
+export * from "./ProgramProvider"
+export * from "./CompileWithCache"
 
 export * from "./peers/AstNode"
 export * from "./peers/Config"
 export * from "./peers/Context"
-export * from "./peers/Program"
+export * from "./peers/ExternalSource"
+export * from "./peers/Options"
+export * from "./node-utilities/ArkTsConfig"
+export * from "./node-utilities/Program"
 export * from "./peers/ImportPathManager"
 export { global as arktsGlobal } from "./static/global"
+export * from "./wrapper-compat"