@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-5

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -20,12 +20,12 @@ import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../gen
 import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
 import { Context } from "../peers/Context"
 import { Profiler } from "./profiler"
-import { Program } from "../peers/Program"
+import { ArkTsConfig } from "../../generated"
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
-    public static packageName: string = ""
-    public static filePathFromPackageRoot: string = global.filePath
+
+    public static arktsconfig?: ArkTsConfig
 
     private static _config?: KNativePointer
     public static set config(config: KNativePointer) {
@@ -37,10 +37,13 @@ export class global {
     public static configIsInitialized(): boolean {
         return global._config !== undefined && global._config !== nullptr
     }
+    public static resetConfig(): void {
+        global._config = undefined
+    }
 
     // TODO: rename to contextPeer
     public static get context(): KNativePointer {
-        return global.compilerContext.peer ?? throwError('Global.context not initialized')
+        return global.compilerContext?.peer ?? throwError('Global.context not initialized')
     }
 
     // TODO: rename to context when the pointer valued one is eliminated
@@ -70,4 +73,7 @@ export class global {
     }
 
     public static profiler = new Profiler()
+
+    // Check node type values during node creation
+    public static validatePeerTypes = false
 }

package/build/libarkts-copy/src/arkts-api/static/profiler.ts

@@ -13,28 +13,185 @@
  * limitations under the License.
  */
 
-export class Profiler {
-    totalTime = 0
-    transformTime = 0
-    proceedTime = 0
-    restartTime = 0
-    visitedNodes = 0
-    createdNodes = 0
+import * as fs from "fs"
+import * as path from "path"
+import { Es2pandaContextState } from "../../generated/Es2pandaEnums"
+import { global } from "./global"
+
+const PERFORMANCE_DATA_DIR = "./performance-results/"
+
+interface PluginData {
+    transformTime: number
+    transformTimeDeps: number
+    visitedNodes: number
+    createdNodes: number
+    contextState?: Es2pandaContextState
+}
+
+function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
+    return {
+        transformTime: 0,
+        transformTimeDeps: 0,
+        visitedNodes: 0,
+        createdNodes: 0,
+        contextState: contextState
+    }
+}
+
+interface PerformanceData {
+    filePath: string
+
+    visitedNodes: number
+    createdNodes: number
+    restartTime: number
+    proceedTime: number
+    totalTime: number
+
+    pluginsByName: Record<string, PluginData>
+}
+
+interface PerformanceDataFile {
+    data: PerformanceData[]
+    summary?: PerformanceData
+}
+
+function parseFile(performanceFile: string): PerformanceDataFile | undefined {
+    if (!fs.existsSync(performanceFile)) return undefined
+
+    const data = fs.readFileSync(path.resolve(performanceFile)).toString()
+    if (!data.length) return undefined
+    return JSON.parse(data) as PerformanceDataFile
+}
+
+export class Profiler implements PerformanceData {
+    filePath: string = ""
+    visitedNodes: number = 0
+    createdNodes: number = 0
+    restartTime: number = 0
+    proceedTime: number = 0
+    totalTime: number = 0
+    pluginsByName: Record<string, PluginData> = {}
+
+    curPlugin: string = ""
+    curContextState?: Es2pandaContextState
+
+    private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData {
+        if (!(pluginName in this.pluginsByName)) {
+            this.pluginsByName[pluginName] = emptyPluginData(contextState)
+        }
+        return this.pluginsByName[pluginName]
+    }
+
+    disableReport = false
+
+    nodeCreated() {
+        this.createdNodes++
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++
+    }
+
+    nodeVisited() {
+        this.visitedNodes++
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++
+    }
+
+    private transformStartTime = 0
+    transformStarted() {
+        this.transformStartTime = Date.now()
+    }
+    private transformDepStartTime = 0
+    transformDepStarted() {
+        this.transformDepStartTime = Date.now()
+    }
+
+    transformEnded(state: Es2pandaContextState, pluginName: string) {
+        const transformEndTime = Date.now()
+        const consumedTime = transformEndTime - this.transformStartTime
+        this.getPluginData(pluginName, state).transformTime += consumedTime
+    }
+
+    transformDepEnded(state: Es2pandaContextState, pluginName: string) {
+        const transformEndTime = Date.now()
+        const consumedTime = transformEndTime - this.transformDepStartTime
+        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime
+    }
+
+    restarted(consumedTime: number) {
+        this.restartTime += consumedTime
+    }
+
+    proceededToState(consumedTime: number) {
+        this.proceedTime += consumedTime
+    }
+
+    private compilationStartTime = 0
+    compilationStarted(filePath: string) {
+        this.filePath = filePath
+
+        this.visitedNodes = 0
+        this.createdNodes = 0
+        this.restartTime = 0
+        this.proceedTime = 0
+        this.totalTime = 0
+        this.pluginsByName = {}
+
+        this.curPlugin = ""
+        this.compilationStartTime = Date.now()
+    }
+
+    compilationEnded() {
+        const consumedTime: number = Date.now() - this.compilationStartTime
+        this.totalTime = consumedTime
+    }
 
     report() {
-        console.log(
-            "total compiler:",
-            this.totalTime,
-            " proceeds:",
-            this.proceedTime,
-            " restarts",
-            this.restartTime,
-            " transforms:",
-            this.transformTime,
-            " visited:",
-            this.visitedNodes,
-            " created:",
-            this.createdNodes
-        )
-    }
-}
+        Object.entries(this.pluginsByName).forEach((data, key) => {
+            console.log(data[0], "totalTransformTime =", data[1].transformTime, "ms")
+            console.log(data[0], "totalDepsTransformTime =", data[1].transformTimeDeps, "ms")
+        })
+    }
+
+    reportToFile(withSummary: boolean = false) {
+        if (this.disableReport) return
+        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR)
+        fs.mkdirSync(outDir, { recursive: true })
+        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + ".json"
+    
+        const data: PerformanceDataFile = { data: [this as PerformanceData] }
+        if (!fs.existsSync(outFilePath)) {
+            fs.writeFileSync(outFilePath, JSON.stringify(data))
+        } else {
+            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data
+            savedData.data.push(this as PerformanceData)
+
+            if (withSummary) {
+                const summary: PerformanceData = {
+                    filePath: this.filePath,
+                    visitedNodes: savedData.data.map(it => it.visitedNodes).reduce((sum, it) => sum + it),
+                    createdNodes: savedData.data.map(it => it.createdNodes).reduce((sum, it) => sum + it),
+                    restartTime: savedData.data.map(it => it.restartTime).reduce((sum, it) => sum + it),
+                    proceedTime: savedData.data.map(it => it.proceedTime).reduce((sum, it) => sum + it),
+                    totalTime: savedData.data.map(it => it.totalTime).reduce((sum, it) => sum + it),
+                    pluginsByName: {}
+                }
+                const pluginNames = new Set(savedData.data.flatMap(it => Object.keys(it.pluginsByName)))
+                for (const pluginName of pluginNames) {
+                    const sumTransformTime = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTime).reduce((sum, it) => sum+it)
+                    const sumTransformTimeDeps = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTimeDeps).reduce((sum, it) => sum+it)
+                    const sumCreatedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].createdNodes).reduce((sum, it) => sum+it)
+                    const sumVisitedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].visitedNodes).reduce((sum, it) => sum+it)
+
+                    summary.pluginsByName[pluginName] = {
+                        transformTime: sumTransformTime,
+                        transformTimeDeps: sumTransformTimeDeps,
+                        createdNodes: sumCreatedNodes,
+                        visitedNodes: sumVisitedNodes,
+                    }
+                }
+
+                savedData.summary = summary
+            }
+
+            fs.writeFileSync(outFilePath, JSON.stringify(savedData))
+        }
+    }
+}

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

@@ -43,21 +43,24 @@ export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType):
     if (peer === nullptr) {
         throwError(`invalid peer`)
     }
-    const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
-    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) {
-        // TODO: Struct is a child class of Class
-        return
-    }
-    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) {
-        // TODO: ETSImportDeclaration is a child of a ImportDeclaration
-        return
-    }
-    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) {
-        // TODO: ETSModule is a child of a BlockStatement
-        return
-    }
-    if (peerType !== expectedKind) {
-        throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`)
+
+    if (global.validatePeerTypes) {
+        const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
+        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) {
+            // TODO: Struct is a child class of Class
+            return
+        }
+        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) {
+            // TODO: ETSImportDeclaration is a child of a ImportDeclaration
+            return
+        }
+        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) {
+            // TODO: ETSModule is a child of a BlockStatement
+            return
+        }
+        if (peerType !== expectedKind) {
+            throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`)
+        }
     }
 }
 
@@ -121,13 +124,9 @@ export function unpackString(peer: KNativePointer): string {
 
 // TODO: use direct string arguments instead.
 export function passString(str: string | undefined): string {
-    if (str === undefined) {
-        return ""
-    }
-    return withString(str, (it: string) => it)
+    return str ?? ""
 }
 
-
 // TODO: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
     return withStringArray(strings, (it: string[]) => it)
@@ -147,14 +146,13 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
     if (original.peer === nullptr) {
         throwError('update called on NULLPTR')
     }
-    if (original instanceof AstNode) {
-        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.originalPeer)
-    }
+    original.onUpdate(node)
     global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
-    global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
+    global.es2panda._AstNodeSetChildrenParentPtr(global.context, node.peer)
     return node
 }
 
 export function nodeType(node: AstNode): Es2pandaAstNodeType {
     return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node))
 }
+

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

@@ -14,16 +14,16 @@
  */
 
 import { global } from "../static/global"
-import { isNumber, throwError } from "../../utils"
+import { isNumber, throwError, withWarning } from "../../utils"
 import { KNativePointer, nullptr } from "@koalaui/interop"
 import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
 import { Es2pandaContextState, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
+import { isSameNativeObject } from "../peers/ArktsObject"
 import {
     type AnnotationUsage,
     ClassDefinition,
     ClassProperty,
-    ETSImportDeclaration,
     ETSModule,
     isClassDefinition,
     isFunctionDeclaration,
@@ -35,13 +35,19 @@ import {
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
+import { listPrograms } from "../plugins"
 
 export function createETSModuleFromContext(): ETSModule {
     let program = global.es2panda._ContextProgram(global.context)
     if (program == nullptr) {
         throw new Error(`Program is null for context ${global.context.toString(16)}`)
     }
-    return new ETSModule(global.es2panda._ProgramAst(global.context, program))
+    const ast = global.es2panda._ProgramAst(global.context, program)
+    if (ast == nullptr) {
+        throw new Error(`AST is null for program ${program.toString(16)}`)
+
+    }
+    return new ETSModule(ast)
 }
 
 export function createETSModuleFromSource(
@@ -59,10 +65,18 @@ export function createETSModuleFromSource(
     return new ETSModule(global.es2panda._ProgramAst(global.context, program))
 }
 
+export function metaDatabase(fileName: string): string {
+    if (fileName.endsWith(".meta.json")) throw new Error(`Must pass source, not database: ${fileName}`)
+    return `${fileName}.meta.json`
+}
+
 export function updateETSModuleByStatements(
     node: ETSModule,
     statements: readonly AstNode[],
 ): ETSModule {
+    if (isSameNativeObject(statements, node.statements)) {
+        return node
+    }
     global.generatedEs2panda._BlockStatementSetStatements(global.context, node.peer, passNodeArray(statements), statements.length)
     return node
 }
@@ -83,7 +97,7 @@ export function proceedToState(state: Es2pandaContextState): void {
     const before = Date.now()
     global.es2panda._ProceedToState(global.context, state)
     const after = Date.now()
-    global.profiler.proceedTime += after-before
+    global.profiler.proceededToState(after-before)
     NodeCache.clear()
     checkErrors()
 }
@@ -102,6 +116,19 @@ export function rebindSubtree(node: AstNode): void {
     checkErrors()
 }
 
+export function recheckContext(context: KNativePointer): void {
+    global.es2panda._AstNodeRecheck(
+        context,
+        global.es2panda._ProgramAst(
+            context,
+            global.es2panda._ContextProgram(
+                context
+            )
+        )
+    )
+    checkErrors()
+}
+
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
         return getDecl(node.property!)
@@ -139,14 +166,6 @@ export function getFileName(): string {
     return global.filePath
 }
 
-export function getPackageName(): string {
-    return global.packageName
-}
-
-export function getFilePathFromPackageRoot(): string {
-    return global.filePathFromPackageRoot
-}
-
 // TODO: It seems like Definition overrides AstNode  modifiers
 // with it's own modifiers which is completely unrelated set of flags.
 // Use this function if you need
@@ -197,3 +216,26 @@ export function nameIfETSModule(node: AstNode): string {
 export function asString(node: AstNode|undefined): string {
     return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}`
 }
+
+const defaultPandaSdk = "../../../incremental/tools/panda/node_modules/@panda/sdk"
+
+
+export function findStdlib(): string {
+    const sdk = process.env.PANDA_SDK_PATH ?? withWarning(
+        defaultPandaSdk,
+        `PANDA_SDK_PATH not set, assuming ${defaultPandaSdk}`
+    )
+    return `${sdk}/ets/stdlib`
+}
+
+export function collectDependencies(files: string[], configPath: string): string[] {
+    const result = new Set<string>()
+    for (let file of files) {
+        const context = Context.createFromFile(file, configPath, findStdlib(), "/tmp/foo.abc")!
+        global.compilerContext = context
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        listPrograms(context.program).forEach(it => result.add(it.absoluteName))
+        context.destroy()
+    }
+    return Array.from(result)
+}

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

@@ -13,66 +13,65 @@
  * limitations under the License.
  */
 
-import { factory } from "./factory/nodeFactory"
-import { AstNode } from "./peers/AstNode"
 import {
     isArrayExpression,
     isArrowFunctionExpression,
     isAssignmentExpression,
+    isBinaryExpression,
     isBlockExpression,
     isBlockStatement,
-    isBinaryExpression,
     isCallExpression,
     isChainExpression,
     isClassDeclaration,
     isClassDefinition,
+    isClassProperty,
     isConditionalExpression,
+    isDoWhileStatement,
+    isETSFunctionType,
+    isETSImportDeclaration,
     isETSModule,
+    isETSNewClassInstanceExpression,
+    isETSParameterExpression,
     isETSStructDeclaration,
     isETSTuple,
+    isETSTypeReference,
+    isETSTypeReferencePart,
+    isETSUnionType,
     isExpressionStatement,
+    isForInStatement,
+    isForOfStatement,
+    isForUpdateStatement,
     isFunctionDeclaration,
     isFunctionExpression,
+    isIdentifier,
     isIfStatement,
     isMemberExpression,
     isMethodDefinition,
     isObjectExpression,
+    isProperty,
     isReturnStatement,
     isScriptFunction,
+    isSwitchCaseStatement,
+    isSwitchStatement,
     isTemplateLiteral,
     isTryStatement,
     isTSAsExpression,
     isTSInterfaceBody,
     isTSInterfaceDeclaration,
+    isTSNonNullExpression,
     isTSTypeAliasDeclaration,
+    isTSTypeParameterDeclaration,
+    isTSTypeParameterInstantiation,
+    isUpdateExpression,
     isVariableDeclaration,
     isVariableDeclarator,
-    isClassProperty,
-    isIdentifier,
-    isETSParameterExpression,
-    isETSUnionType,
-    isETSFunctionType,
-    isWhileStatement,
-    isForUpdateStatement,
-    isForInStatement,
-    isForOfStatement,
-    isDoWhileStatement,
-    isSwitchStatement,
-    isSwitchCaseStatement,
-    isETSImportDeclaration,
-    isProperty,
-    isETSNewClassInstanceExpression,
-    isClassStaticBlock,
-    isTSNonNullExpression,
-    isUpdateExpression,
-    isETSTypeReference,
-    isETSTypeReferencePart,
-    isTSTypeParameterInstantiation,
-    isTSTypeParameterDeclaration
+    isWhileStatement
 } from "../generated"
-import { updateETSModuleByStatements } from "./utilities/public"
+import { Es2pandaImportKinds } from "../generated/Es2pandaEnums"
+import { factory } from "./factory/nodeFactory"
+import { AstNode } from "./peers/AstNode"
 import { global } from "./static/global"
-import { Es2pandaImportKinds, Es2pandaScriptFunctionFlags } from "../generated/Es2pandaEnums"
+import { updateETSModuleByStatements } from "./utilities/public"
 
 type Visitor = (node: AstNode, options?: object) => AstNode
 
@@ -145,7 +144,7 @@ export function visitEachChild(
     node: AstNode,
     visitor: Visitor
 ): AstNode {
-    global.profiler.visitedNodes ++
+    global.profiler.nodeVisited()
     if (isETSModule(node)) {
         return updateETSModuleByStatements(
             node,
@@ -202,12 +201,11 @@ export function visitEachChild(
         )
     }
     if (isClassDeclaration(node)) {
-        const _node = factory.updateClassDeclaration(
+        return factory.updateClassDeclaration(
             node,
-            nodeVisitor(node.definition, visitor)
+            nodeVisitor(node.definition, visitor),
+            node.modifierFlags,
         )
-        _node.modifierFlags = node.modifierFlags
-        return _node
     }
     if (isClassDefinition(node)) {
         return factory.updateClassDefinition(
@@ -258,7 +256,6 @@ export function visitEachChild(
             nodeVisitor(node.ident, visitor),
             node.isOptional,
             nodeVisitor(node.initializer, visitor),
-            nodeVisitor(node.typeAnnotation, visitor),
             nodesVisitor(node.annotations, visitor),
         )
     }
@@ -459,8 +456,8 @@ export function visitEachChild(
     if (isBinaryExpression(node)) {
         return factory.updateBinaryExpression(
             node,
-            node.left,
-            node.right,
+            nodeVisitor(node.left, visitor),
+            nodeVisitor(node.right, visitor),
             node.operatorType)
     }
     if (isIdentifier(node)) {
@@ -518,14 +515,12 @@ export function visitEachChild(
         )
     }
     if (isETSImportDeclaration(node)) {
-        /*
         return factory.updateETSImportDeclaration(
             node,
             nodeVisitor(node.source, visitor),
             nodesVisitor(node.specifiers, visitor),
             Es2pandaImportKinds.IMPORT_KINDS_ALL
         )
-        */
     }
     if (isTSNonNullExpression(node)) {
         return factory.updateTSNonNullExpression(

package/build/libarkts-copy/src/arkts-api/wrapper-compat.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+// koala-wrapper compatibility helpers
+
+import { KNativePointer } from "@koalaui/interop"
+import { ETSModule } from "../generated"
+import { createETSModuleFromContext } from "./utilities/public"
+import { global } from "./static/global"
+
+export class EtsScript {
+    public static fromContext(): ETSModule {
+        return createETSModuleFromContext()
+    }
+}
+
+export function destroyConfig(config: KNativePointer): void {
+    global.es2panda._DestroyConfig(config)
+    global.resetConfig()
+}

package/build/libarkts-copy/src/checkSdk.ts

@@ -0,0 +1,25 @@
+import * as fs from "fs"
+import * as path from "path"
+
+function reportErrorAndExit(message: string): never {
+    console.error(message)
+    process.exit(1)
+}
+
+export function checkSDK() {
+    const panda = process.env.PANDA_SDK_PATH
+    if (!panda)
+        reportErrorAndExit(`Variable PANDA_SDK_PATH is not set, please fix`)
+    if (!fs.existsSync(path.join(panda, 'package.json')))
+        reportErrorAndExit(`Variable PANDA_SDK_PATH not points to SDK`)
+    const packageJson = JSON.parse(fs.readFileSync(path.join(panda, 'package.json')).toString())
+    const version = packageJson.version as string
+    if (!version)
+        reportErrorAndExit(`version is unknown`)
+    const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString())
+    const expectedVersion = packageJsonOur.config.panda_sdk_version
+    if (expectedVersion && expectedVersion != "next" && version != expectedVersion)
+        console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`)
+    else
+        console.log(`Using Panda ${version}`)
+}