@idlizer/arktscgen 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

package/build/libarkts-copy/src/ts-api/utilities/private.ts

@@ -13,27 +13,23 @@
  * limitations under the License.
  */
 
-import { throwError } from "../../utils"
+import { throwError } from '../../utils';
 
-import * as ts from "../"
-import * as arkts from "../../arkts-api"
+import * as ts from '../';
+import * as arkts from '../../arkts-api';
 
-import { KInt } from "@koalaui/interop"
-import {
-    SyntaxKind,
-    TokenSyntaxKind,
-    NodeFlags,
-} from "../static/enums"
+import { KInt } from '@koalaui/interop';
+import { SyntaxKind, TokenSyntaxKind, NodeFlags } from '../static/enums';
 import {
     Es2pandaAstNodeType,
     Es2pandaModifierFlags,
     Es2pandaScriptFunctionFlags,
     Es2pandaTokenType,
     Es2pandaVariableDeclarationKind,
-} from "../../arkts-api"
+} from '../../arkts-api';
 
-export function emptyImplementation(): any {
-    throwError("Not yet implemented")
+export function emptyImplementation(): never {
+    return throwError('Not yet implemented');
 }
 
 type kindTypes =
@@ -48,9 +44,9 @@ type kindTypes =
     | { new (node: arkts.ETSParameterExpression): ts.ParameterDeclaration }
     | { new (node: arkts.CallExpression): ts.CallExpression }
     | { new (node: arkts.BlockStatement): ts.Block }
-    | { new (node: arkts.TSTypeParameter): ts.TypeParameterDeclaration}
-    | { new (node: arkts.MemberExpression): ts.PropertyAccessExpression}
-    | { new (node: arkts.IfStatement): ts.IfStatement}
+    | { new (node: arkts.TSTypeParameter): ts.TypeParameterDeclaration }
+    | { new (node: arkts.MemberExpression): ts.PropertyAccessExpression }
+    | { new (node: arkts.IfStatement): ts.IfStatement }
     | { new (node: arkts.ETSTypeReference): ts.TypeReferenceNode }
     | { new (node: arkts.ETSPrimitiveType | arkts.ETSTypeReference): ts.KeywordTypeNode }
     | { new (node: arkts.BinaryExpression): ts.BinaryExpression }
@@ -59,104 +55,109 @@ type kindTypes =
     | { new (node: arkts.ClassDeclaration): ts.ClassDeclaration }
     | { new (node: arkts.MethodDefinition): ts.MethodDeclaration }
     | { new (node: arkts.VariableDeclarator): ts.VariableDeclaration }
-    | { new (node: arkts.VariableDeclaration): ts.VariableStatement }
+    | { new (node: arkts.VariableDeclaration): ts.VariableStatement };
 
 export function classByEtsNode(node: arkts.AstNode) {
-    const types =
-        new Map<Es2pandaAstNodeType, kindTypes>([
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, ts.SourceFile],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, ts.Identifier],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, ts.StringLiteral],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, ts.NumericLiteral],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ts.ExpressionStatement],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, ts.FunctionDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ts.ReturnStatement],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ts.ParameterDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, ts.CallExpression],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, ts.Block],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ts.TypeReferenceNode],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, ts.TypeParameterDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, ts.PropertyAccessExpression],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, ts.IfStatement],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ts.KeywordTypeNode],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, ts.BinaryExpression],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ts.UnionTypeNode],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ts.ArrowFunction],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ts.ClassDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, ts.MethodDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, ts.VariableStatement],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, ts.VariableDeclaration],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, ts.SuperExpression],
+    const types = new Map<Es2pandaAstNodeType, kindTypes>([
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, ts.SourceFile],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, ts.Identifier],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, ts.StringLiteral],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, ts.NumericLiteral],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ts.ExpressionStatement],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, ts.FunctionDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ts.ReturnStatement],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ts.ParameterDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, ts.CallExpression],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, ts.Block],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ts.TypeReferenceNode],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, ts.TypeParameterDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, ts.PropertyAccessExpression],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, ts.IfStatement],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ts.KeywordTypeNode],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, ts.BinaryExpression],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ts.UnionTypeNode],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ts.ArrowFunction],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ts.ClassDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, ts.MethodDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, ts.VariableStatement],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, ts.VariableDeclaration],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, ts.SuperExpression],
 
-            [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ts.UnsupportedNode],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ts.UnsupportedNode],
-            [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, ts.UnsupportedNode],
-        ])
+        [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ts.UnsupportedNode],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ts.UnsupportedNode],
+        [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, ts.UnsupportedNode],
+    ]);
 
-    return types.get(node.type) ?? throwError(`UNSUPPORTED NODE (ts): ${Es2pandaAstNodeType[node.type]}`)
+    return types.get(node.type) ?? throwError(`UNSUPPORTED NODE (ts): ${Es2pandaAstNodeType[node.type]}`);
 }
 
 // Improve: add checks for casts in functions below
 
-export function unpackNode<U extends arkts.AstNode, T extends ts.Node<U> >(node: U): T
-export function unpackNode<U extends arkts.AstNode | undefined, T extends ts.Node<U> >(node: U): T | undefined
-export function unpackNode<U extends arkts.AstNode | undefined, T extends ts.Node<U> >(node: U): T | undefined {
+export function unpackNode<U extends arkts.AstNode, T extends ts.Node<U>>(node: U): T;
+export function unpackNode<U extends arkts.AstNode | undefined, T extends ts.Node<U>>(node: U): T | undefined;
+export function unpackNode<U extends arkts.AstNode | undefined, T extends ts.Node<U>>(node: U): T | undefined {
     if (node === undefined) {
-        return undefined
+        return undefined;
     }
-    return (new (classByEtsNode(node))(node as any)) as T
+    return new (classByEtsNode(node))(node as any) as T;
 }
 
-export function passNode<T extends arkts.AstNode>(node: ts.Node<T>): T
-export function passNode<T extends arkts.AstNode>(node: ts.Node<T> | undefined): T | undefined
+export function passNode<T extends arkts.AstNode>(node: ts.Node<T>): T;
+export function passNode<T extends arkts.AstNode>(node: ts.Node<T> | undefined): T | undefined;
 export function passNode<T extends arkts.AstNode>(node: ts.Node<T> | undefined): T | undefined {
     if (node === undefined) {
-        return undefined
+        return undefined;
     }
-    return (node.node as T) ?? throwError('trying to pass non-compatible node')
+    return (node.node as T) ?? throwError('trying to pass non-compatible node');
 }
 
-export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode> >(nodes: readonly U[]): ts.NodeArray<T>
-export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode> >(nodes: readonly U[] | undefined): ts.NodeArray<T> | undefined
-export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode> >(nodes: readonly U[] | undefined): ts.NodeArray<T> | undefined {
-    return nodes?.map((node: U) => unpackNode(node)) as ReadonlyArray<ts.Node<arkts.AstNode> > as ts.NodeArray<T>
+export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode>>(
+    nodes: readonly U[]
+): ts.NodeArray<T>;
+export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode>>(
+    nodes: readonly U[] | undefined
+): ts.NodeArray<T> | undefined;
+export function unpackNodeArray<U extends arkts.AstNode | undefined, T extends ts.Node<arkts.AstNode>>(
+    nodes: readonly U[] | undefined
+): ts.NodeArray<T> | undefined {
+    return nodes?.map((node: U) => unpackNode(node)) as ReadonlyArray<ts.Node<arkts.AstNode>> as ts.NodeArray<T>;
 }
 
-export function passNodeArray<T extends arkts.AstNode>(nodes: readonly ts.Node<T>[]): T[]
-export function passNodeArray<T extends arkts.AstNode>(nodes: readonly ts.Node<T>[] | undefined): T[] | undefined
+export function passNodeArray<T extends arkts.AstNode>(nodes: readonly ts.Node<T>[]): T[];
+export function passNodeArray<T extends arkts.AstNode>(nodes: readonly ts.Node<T>[] | undefined): T[] | undefined;
 export function passNodeArray<T extends arkts.AstNode>(nodes: readonly ts.Node<T>[] | undefined): T[] | undefined {
-    return nodes?.map((node: ts.Node<T>) => passNode<T>(node))
+    return nodes?.map((node: ts.Node<T>) => passNode<T>(node));
 }
 
-export function passIdentifier(node: ts.Identifier | string, typeAnnotation?: ts.TypeNode): arkts.Identifier
-export function passIdentifier(node: ts.Identifier | string | undefined, typeAnnotation?: ts.TypeNode): arkts.Identifier | undefined
-export function passIdentifier(node: ts.Identifier | string | undefined, typeAnnotation?: ts.TypeNode): arkts.Identifier | undefined {
+export function passIdentifier(node: ts.Identifier | string, typeAnnotation?: ts.TypeNode): arkts.Identifier;
+export function passIdentifier(
+    node: ts.Identifier | string | undefined,
+    typeAnnotation?: ts.TypeNode
+): arkts.Identifier | undefined;
+export function passIdentifier(
+    node: ts.Identifier | string | undefined,
+    typeAnnotation?: ts.TypeNode
+): arkts.Identifier | undefined {
     if (node === undefined) {
-        return undefined
+        return undefined;
     }
     if (node instanceof ts.Identifier) {
         if (typeAnnotation === undefined) {
-            return node.node
+            return node.node;
         }
-        return arkts.Identifier.create(
-            node.node.name,
-            passNode(typeAnnotation)
-        )
+        return arkts.Identifier.create(node.node.name, passNode(typeAnnotation));
     }
-    return arkts.Identifier.create(
-        node,
-        passNode(typeAnnotation)
-    )
+    return arkts.Identifier.create(node, passNode(typeAnnotation));
 }
 
 // Improve: support optional params
-export function passTypeParams(params: readonly ts.TypeParameterDeclaration[] | undefined): arkts.TSTypeParameterDeclaration | undefined {
+export function passTypeParams(
+    params: readonly ts.TypeParameterDeclaration[] | undefined
+): arkts.TSTypeParameterDeclaration | undefined {
     if (params === undefined) {
-        return undefined
+        return undefined;
     }
-    return arkts.factory.createTypeParameterDeclaration(
-        passNodeArray(params)
-    )
+    return arkts.factory.createTypeParameterDeclaration(passNodeArray(params));
 }
 
 export function unpackModifiers(modifiers: KInt | undefined): ts.NodeArray<ts.Modifier> {
@@ -182,28 +183,30 @@ export function unpackModifiers(modifiers: KInt | undefined): ts.NodeArray<ts.Mo
         [Es2pandaModifierFlags.MODIFIER_FLAGS_OVERRIDE, SyntaxKind.OverrideKeyword],
         [Es2pandaModifierFlags.MODIFIER_FLAGS_READONLY, SyntaxKind.ReadonlyKeyword],
         [Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, SyntaxKind.StaticKeyword],
-    ])
+    ]);
 
-    const bits = function*(flags: KInt) {
-        let bit: KInt = 1
+    const bits = function* (flags: KInt) {
+        let bit: KInt = 1;
         while (flags >= bit) {
-        if ((flags & bit) > 0) {
-            yield bit
-        }
-        bit <<= 1
+            if ((flags & bit) > 0) {
+                yield bit;
+            }
+            bit <<= 1;
         }
-    }
+    };
     if (modifiers === undefined) {
-        return [] as ReadonlyArray<ts.Modifier> as ts.NodeArray<ts.Modifier>
+        return [] as ReadonlyArray<ts.Modifier> as ts.NodeArray<ts.Modifier>;
     }
-    let mods: ts.Modifier[] = []
+    let mods: ts.Modifier[] = [];
     for (const bit of bits(modifiers)) {
-        mods.push(new ts.Modifier(translation.get(bit) ?? throwError(`Unsupported modifier: ${bit}`)))
+        mods.push(new ts.Modifier(translation.get(bit) ?? throwError(`Unsupported modifier: ${bit}`)));
     }
-    return mods as ReadonlyArray<ts.Modifier> as ts.NodeArray<ts.Modifier>
+    return mods as ReadonlyArray<ts.Modifier> as ts.NodeArray<ts.Modifier>;
 }
 
-export function passModifiers(modifiers: ReadonlyArray<ts.Modifier | undefined | Es2pandaModifierFlags> | undefined): KInt {
+export function passModifiers(
+    modifiers: ReadonlyArray<ts.Modifier | undefined | Es2pandaModifierFlags> | undefined
+): KInt {
     const translation = new Map<ts.ModifierSyntaxKind, Es2pandaModifierFlags>([
         // [SyntaxKind.UnknownKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_NONE],
         // [SyntaxKind.ConstructorKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR],
@@ -224,25 +227,22 @@ export function passModifiers(modifiers: ReadonlyArray<ts.Modifier | undefined |
         [SyntaxKind.OverrideKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_OVERRIDE],
         [SyntaxKind.ReadonlyKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_READONLY],
         [SyntaxKind.StaticKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC],
-    ])
+    ]);
 
     if (modifiers === undefined) {
-        return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE
+        return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE;
     }
     return modifiers
         .map((mod: ts.Modifier | undefined | Es2pandaModifierFlags) => {
             if (mod === undefined) {
-                return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE
+                return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE;
             }
             if (typeof mod === 'object') {
-                return translation.get(mod.kind) ?? throwError(`Unsupported modifier: ${mod.kind}`)
+                return translation.get(mod.kind) ?? throwError(`Unsupported modifier: ${mod.kind}`);
             }
-            return mod
+            return mod;
         })
-        .reduce(
-            (prev, curr) => (prev | curr),
-            Es2pandaModifierFlags.MODIFIER_FLAGS_NONE
-        )
+        .reduce((prev, curr) => prev | curr, Es2pandaModifierFlags.MODIFIER_FLAGS_NONE);
 }
 
 export function passToken<TKind extends TokenSyntaxKind>(token: ts.Token<TKind>): KInt {
@@ -250,9 +250,9 @@ export function passToken<TKind extends TokenSyntaxKind>(token: ts.Token<TKind>)
         [SyntaxKind.PlusToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS],
         [SyntaxKind.MinusToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS],
         [SyntaxKind.AsteriskToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MULTIPLY],
-    ])
+    ]);
 
-    return translation.get(token.kind) ?? throwError('unsupported token')
+    return translation.get(token.kind) ?? throwError('unsupported token');
 }
 
 export function passModifiersToScriptFunction(modifiers: readonly ts.Modifier[] | undefined): KInt {
@@ -260,12 +260,15 @@ export function passModifiersToScriptFunction(modifiers: readonly ts.Modifier[]
         [SyntaxKind.StaticKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_STATIC_BLOCK],
         [SyntaxKind.AsyncKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ASYNC],
         [SyntaxKind.PublicKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE],
-    ])
+    ]);
 
-    return modifiers?.reduce(
-        (prev, curr) => prev | (translation.get(curr.kind) ?? throwError(`Unsupported ScriptFunction flag: ${curr.kind}`)),
-        Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE
-    ) ?? Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE
+    return (
+        modifiers?.reduce(
+            (prev, curr) =>
+                prev | (translation.get(curr.kind) ?? throwError(`Unsupported ScriptFunction flag: ${curr.kind}`)),
+            Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE
+        ) ?? Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE
+    );
 }
 
 export function passVariableDeclarationKind(flags: NodeFlags): Es2pandaVariableDeclarationKind {
@@ -273,9 +276,9 @@ export function passVariableDeclarationKind(flags: NodeFlags): Es2pandaVariableD
         [NodeFlags.Const, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST],
         [NodeFlags.Let, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET],
         [NodeFlags.None, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_VAR],
-    ])
+    ]);
 
-    return translation.get(flags) ?? throwError('unsupported VariableDeclarationKind')
+    return translation.get(flags) ?? throwError('unsupported VariableDeclarationKind');
 }
 
 export function unpackVariableDeclarationKind(kind: Es2pandaVariableDeclarationKind): NodeFlags {
@@ -283,7 +286,7 @@ export function unpackVariableDeclarationKind(kind: Es2pandaVariableDeclarationK
         [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, NodeFlags.Const],
         [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, NodeFlags.Let],
         [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_VAR, NodeFlags.None],
-    ])
+    ]);
 
-    return translation.get(kind) ?? throwError('unsupported VariableDeclarationKind')
+    return translation.get(kind) ?? throwError('unsupported VariableDeclarationKind');
 }

package/build/libarkts-copy/src/ts-api/utilities/public.ts

@@ -13,43 +13,43 @@
  * limitations under the License.
  */
 
-import { global } from "../../arkts-api/static/global"
-import { throwError } from "../../utils"
-import * as ts from "../."
-import { KNativePointer, nullptr } from "@koalaui/interop"
-import { unpackNonNullableNode } from "../../arkts-api"
+import { global } from '../../arkts-api/static/global';
+import { throwError } from '../../utils';
+import * as ts from '../.';
+import { KNativePointer, nullptr } from '@koalaui/interop';
+import { unpackNonNullableNode } from '../../arkts-api';
 
-export { proceedToState, startChecker } from "../../arkts-api"
+export { proceedToState, startChecker } from '../../arkts-api';
 
 // Improve: like in arkts utils
 export function getDecl(node: ts.Node): ts.Node | undefined {
     if (node.node === undefined) {
-        throwError('there is no arkts pair of ts node (unable to getDecl)')
+        throwError('there is no arkts pair of ts node (unable to getDecl)');
     }
-    let decl: KNativePointer = node.node.peer
-    decl = global.es2panda._AstNodeVariableConst(global.context, decl)
+    let decl: KNativePointer = node.node.peer;
+    decl = global.es2panda._AstNodeVariableConst(global.context, decl);
     if (decl === nullptr) {
-        return undefined
+        return undefined;
     }
-    decl = global.es2panda._VariableDeclaration(global.context, decl)
+    decl = global.es2panda._VariableDeclaration(global.context, decl);
     if (decl === nullptr) {
-        return undefined
+        return undefined;
     }
-    decl = global.es2panda._DeclNode(global.context, decl)
+    decl = global.es2panda._DeclNode(global.context, decl);
     if (decl === nullptr) {
-        return undefined
+        return undefined;
     }
-    return ts.unpackNode(unpackNonNullableNode(decl))
+    return ts.unpackNode(unpackNonNullableNode(decl));
 }
 
 // Improve: like in arkts utils
 export function getOriginalNode(node: ts.Node): ts.Node {
     if (node.node === undefined) {
         // Improve: fix this
-        throwError('there is no arkts pair of ts node (unable to getOriginalNode)')
+        throwError('there is no arkts pair of ts node (unable to getOriginalNode)');
     }
     if (node.node.originalPeer === nullptr) {
-        return node
+        return node;
     }
-    return ts.unpackNode(unpackNonNullableNode(node.node.originalPeer))
+    return ts.unpackNode(unpackNonNullableNode(node.node.originalPeer));
 }

package/build/libarkts-copy/src/ts-api/visitor/visitor.ts

@@ -13,31 +13,34 @@
  * limitations under the License.
  */
 
-import { throwError } from "../../utils"
+import { throwError } from '../../utils';
 
-import * as ts from "../."
-import { factory } from "../factory/nodeFactory"
-import { SyntaxKind } from "../static/enums"
+import * as ts from '../.';
+import { factory } from '../factory/nodeFactory';
+import { SyntaxKind } from '../static/enums';
 
-type Visitor = (node: ts.Node) => ts.Node
+type Visitor = (node: ts.Node) => ts.Node;
 
 // Improve: rethink (remove as)
 function nodeVisitor<T extends ts.Node | undefined>(node: T, visitor: Visitor): T {
     if (node === undefined) {
-        return node
+        return node;
     }
-    return visitor(node) as T
+    return visitor(node) as T;
 }
 
 // Improve: rethink (remove as)
-function nodesVisitor<T extends ts.Node, TIn extends ts.NodeArray<T> | undefined>(nodes: TIn, visitor: Visitor): T[] | TIn {
+function nodesVisitor<T extends ts.Node, TIn extends ts.NodeArray<T> | undefined>(
+    nodes: TIn,
+    visitor: Visitor
+): T[] | TIn {
     if (nodes === undefined) {
-        return nodes
+        return nodes;
     }
-    return nodes.map(node => visitor(node) as T)
+    return nodes.map((node) => visitor(node) as T);
 }
 
-type VisitEachChildFunction<T extends ts.Node> = (node: T, visitor: Visitor) => T
+type VisitEachChildFunction<T extends ts.Node> = (node: T, visitor: Visitor) => T;
 
 // Improve: add more nodes
 type HasChildren =
@@ -50,17 +53,14 @@ type HasChildren =
     | ts.MethodDeclaration
     | ts.Block
     | ts.VariableStatement
-    | ts.VariableDeclarationList
+    | ts.VariableDeclarationList;
 
-type VisitEachChildTable = { [TNode in HasChildren as TNode["kind"]]: VisitEachChildFunction<TNode> }
+type VisitEachChildTable = { [TNode in HasChildren as TNode['kind']]: VisitEachChildFunction<TNode> };
 
 // Improve: add more nodes
 const visitEachChildTable: VisitEachChildTable = {
     [SyntaxKind.SourceFile]: function (node: ts.SourceFile, visitor: Visitor) {
-        return factory.updateSourceFile(
-            node,
-            nodesVisitor(node.statements, visitor)
-        )
+        return factory.updateSourceFile(node, nodesVisitor(node.statements, visitor));
     },
     [SyntaxKind.FunctionDeclaration]: function (node: ts.FunctionDeclaration, visitor: Visitor) {
         return factory.updateFunctionDeclaration(
@@ -71,14 +71,11 @@ const visitEachChildTable: VisitEachChildTable = {
             nodesVisitor(node.typeParameters, visitor),
             nodesVisitor(node.parameters, visitor),
             nodeVisitor(node.type, visitor),
-            nodeVisitor(node.body, visitor),
-        )
+            nodeVisitor(node.body, visitor)
+        );
     },
     [SyntaxKind.ExpressionStatement]: function (node: ts.ExpressionStatement, visitor: Visitor) {
-        return factory.updateExpressionStatement(
-            node,
-            nodeVisitor(node.expression, visitor)
-        )
+        return factory.updateExpressionStatement(node, nodeVisitor(node.expression, visitor));
     },
     [SyntaxKind.CallExpression]: function (node: ts.CallExpression, visitor: Visitor) {
         return factory.updateCallExpression(
@@ -86,14 +83,14 @@ const visitEachChildTable: VisitEachChildTable = {
             nodeVisitor(node.expression, visitor),
             undefined,
             nodesVisitor(node.arguments, visitor)
-        )
+        );
     },
     [SyntaxKind.PropertyAccessExpression]: function (node: ts.PropertyAccessExpression, visitor: Visitor) {
         return factory.updatePropertyAccessExpression(
             node,
             nodeVisitor(node.expression, visitor),
             nodeVisitor(node.name, visitor)
-        )
+        );
     },
     [SyntaxKind.ClassDeclaration]: function (node: ts.ClassDeclaration, visitor: Visitor) {
         return factory.updateClassDeclaration(
@@ -103,7 +100,7 @@ const visitEachChildTable: VisitEachChildTable = {
             undefined,
             undefined,
             nodesVisitor(node.members, visitor)
-        )
+        );
     },
     [SyntaxKind.MethodDeclaration]: function (node: ts.MethodDeclaration, visitor: Visitor) {
         return factory.updateMethodDeclaration(
@@ -115,41 +112,28 @@ const visitEachChildTable: VisitEachChildTable = {
             undefined,
             nodesVisitor(node.parameters, visitor),
             undefined,
-            nodeVisitor(node.body, visitor),
-        )
+            nodeVisitor(node.body, visitor)
+        );
     },
     [SyntaxKind.Block]: function (node: ts.Block, visitor: Visitor) {
-        return factory.updateBlock(
-            node,
-            nodesVisitor(node.statements, visitor),
-        )
+        return factory.updateBlock(node, nodesVisitor(node.statements, visitor));
     },
     [SyntaxKind.VariableStatement]: function (node: ts.VariableStatement, visitor: Visitor) {
-        return factory.updateVariableStatement(
-            node,
-            undefined,
-            nodeVisitor(node.declarationList, visitor),
-        )
+        return factory.updateVariableStatement(node, undefined, nodeVisitor(node.declarationList, visitor));
     },
     [SyntaxKind.VariableDeclarationList]: function (node: ts.VariableDeclarationList, visitor: Visitor) {
-        return factory.updateVariableDeclarationList(
-            node,
-            nodesVisitor(node.declarations, visitor),
-        )
+        return factory.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor));
     },
-}
+};
 
 function nodeHasChildren(node: ts.Node): node is HasChildren {
-    return node.kind in visitEachChildTable
+    return node.kind in visitEachChildTable;
 }
 
-export function visitEachChild<T extends ts.Node>(
-    node: T,
-    visitor: Visitor
-): T {
+export function visitEachChild<T extends ts.Node>(node: T, visitor: Visitor): T {
     const visitFunc = (visitEachChildTable as Record<SyntaxKind, VisitEachChildFunction<any> | undefined>)[node.kind];
     if (nodeHasChildren(node) && visitFunc === undefined) {
-        throwError('Unsupported node kind: ' + node.kind)
+        throwError('Unsupported node kind: ' + node.kind);
     }
-    return (visitFunc === undefined) ? node : visitFunc(node, visitor);
+    return visitFunc === undefined ? node : visitFunc(node, visitor);
 }