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

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

@@ -15,18 +15,18 @@
 
 // koala-wrapper compatibility helpers
 
-import { KNativePointer } from "@koalaui/interop"
-import { ETSModule } from "../generated"
-import { createETSModuleFromContext } from "./utilities/public"
-import { global } from "./static/global"
+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()
+        return createETSModuleFromContext();
     }
 }
 
 export function destroyConfig(config: KNativePointer): void {
-    global.es2panda._DestroyConfig(config)
-    global.resetConfig()
-}
+    global.es2panda._DestroyConfig(config);
+    global.resetConfig();
+}

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

@@ -13,28 +13,25 @@
  * limitations under the License.
  */
 
-import * as fs from "fs"
-import * as path from "path"
+import * as fs from 'fs';
+import * as path from 'path';
 
 function reportErrorAndExit(message: string): never {
-    console.error(message)
-    process.exit(1)
+    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`)
+    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}`)
+        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}`);
 }

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

@@ -13,35 +13,35 @@
  * limitations under the License.
  */
 
-export * from "./checkSdk"
-export * from "./utils"
-export * from "./reexport-for-generated"
-export * from "./generated/Es2pandaEnums"
-export * from "./generated"
+export * from './checkSdk';
+export * from './utils';
+export * from './reexport-for-generated';
+export * from '../generated/Es2pandaEnums';
+export * from '../generated';
 
-export * from "./arkts-api/utilities/performance"
-export * from "./arkts-api/utilities/private"
-export * from "./arkts-api/utilities/public"
-export * from "./arkts-api/factory/nodeFactory"
-export * from "./arkts-api/visitor"
-export * from "./arkts-api/AbstractVisitor"
-export * from "./arkts-api/plugins"
-export * from "./arkts-api/ImportStorage"
-export * from "./arkts-api/ProgramProvider"
-export * from "./arkts-api/node-utilities/Program"
-export * from "./arkts-api/node-utilities/ArkTsConfig"
+export * from './arkts-api/utilities/performance';
+export * from './arkts-api/utilities/private';
+export * from './arkts-api/utilities/public';
+export * from './arkts-api/factory/nodeFactory';
+export * from './arkts-api/visitor';
+export * from './arkts-api/AbstractVisitor';
+export * from './arkts-api/plugins';
+export * from './arkts-api/ImportStorage';
+export * from './arkts-api/ProgramProvider';
+export * from './arkts-api/node-utilities/Program';
+export * from './arkts-api/node-utilities/ArkTsConfig';
 
-export * from "./arkts-api/peers/AstNode"
-export * from "./arkts-api/peers/Config"
-export * from "./arkts-api/peers/Context"
-export { GlobalContext } from "./arkts-api/peers/Context"
-export * from "./arkts-api/peers/ExternalSource"
-export * from "./arkts-api/peers/ImportPathManager"
-export * from "./arkts-api/peers/Options"
-export * from "./arkts-api/peers/DiagnosticKind"
-export { global as arktsGlobal } from "./arkts-api/static/global"
-export * from "./arkts-api/static/globalUtils"
-export * as arkts from "./arkts-api"
+export * from './arkts-api/peers/AstNode';
+export * from './arkts-api/peers/Config';
+export * from './arkts-api/peers/Context';
+export { GlobalContext } from './arkts-api/peers/Context';
+export * from './arkts-api/peers/ExternalSource';
+export * from './arkts-api/peers/ImportPathManager';
+export * from './arkts-api/peers/Options';
+export * from './arkts-api/peers/DiagnosticKind';
+export { global as arktsGlobal } from './arkts-api/static/global';
+export * from './arkts-api/static/globalUtils';
+export * as arkts from './arkts-api';
 
-export * from "./plugin-utils"
-export * from "./tracer"
+export * from './plugin-utils';
+export * from './tracer';

package/build/libarkts-copy/src/plugin-utils.ts

@@ -23,102 +23,114 @@ import {
     ProgramProvider,
     CompilationOptions,
     dumpProgramSrcFormatted,
-} from "./arkts-api"
-import { Tracer } from "./tracer"
+} from './arkts-api';
+import { Tracer } from './tracer';
 
 export interface RunTransformerHooks {
-    onProgramTransformStart?(options: CompilationOptions, program: Program): void
-    onProgramTransformEnd?(options: CompilationOptions, program: Program): void
+    onProgramTransformStart?(options: CompilationOptions, program: Program): void;
+    onProgramTransformEnd?(options: CompilationOptions, program: Program): void;
 }
 
 class ASTCache {
-    processedPrograms = new Set<string>()
-    constructor() { }
+    processedPrograms = new Set<string>();
+    constructor() {}
     find(program: Program): boolean {
-        return this.processedPrograms.has(program.absoluteName)
+        return this.processedPrograms.has(program.absoluteName);
     }
     update(program: Program) {
-        this.processedPrograms.add(program.absoluteName)
+        this.processedPrograms.add(program.absoluteName);
     }
 }
 
 export class DumpingHooks implements RunTransformerHooks {
-    constructor(private state: Es2pandaContextState, private pluginName: string, private dumpAst: boolean = false) {
+    constructor(
+        private state: Es2pandaContextState,
+        private pluginName: string,
+        private dumpAst: boolean = false
+    ) {
         if (process.env.KOALA_DUMP_PLUGIN_AST) {
-            this.dumpAst = true
+            this.dumpAst = true;
         }
     }
     onProgramTransformStart(options: CompilationOptions, program: Program) {
         if (this.dumpAst) {
-            console.log(`BEFORE ${this.pluginName}:`)
-            dumpProgramSrcFormatted(program, true)
+            console.log(`BEFORE ${this.pluginName}:`);
+            dumpProgramSrcFormatted(program, true);
         }
-        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepStarted()
+        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepStarted();
     }
     onProgramTransformEnd(options: CompilationOptions, program: Program) {
-        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName)
+        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName);
         if (this.dumpAst) {
-            console.log(`AFTER ${this.pluginName}:`)
-            dumpProgramSrcFormatted(program, true)
+            console.log(`AFTER ${this.pluginName}:`);
+            dumpProgramSrcFormatted(program, true);
         }
     }
 }
 
+export function runTransformerOnProgram(
+    program: Program,
+    options: CompilationOptions,
+    transform: ProgramTransformer | undefined,
+    pluginContext: PluginContext,
+    hooks: RunTransformerHooks = {}
+) {
+    arktsGlobal.filePath = program.absoluteName;
 
-export function runTransformerOnProgram(program: Program, options: CompilationOptions, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
-    arktsGlobal.filePath = program.absoluteName
-
-    Tracer.startProgramTracing(program)
+    Tracer.startProgramTracing(program);
 
     // Perform some additional actions before the transformation start
-    hooks.onProgramTransformStart?.(options, program)
+    hooks.onProgramTransformStart?.(options, program);
 
     // Save currently existing imports in the program
-    const importStorage = new ImportStorage(program, options.state == Es2pandaContextState.ES2PANDA_STATE_PARSED)
+    const importStorage = new ImportStorage(program, options.state == Es2pandaContextState.ES2PANDA_STATE_PARSED);
 
     // Run the plugin itself
-    transform?.(program, options, pluginContext)
+    transform?.(program, options, pluginContext);
 
     // Update internal import information based on import modification by plugin
-    importStorage.update()
+    importStorage.update();
 
     // Perform some additional actions after the transformation end
-    hooks.onProgramTransformEnd?.(options, program)
+    hooks.onProgramTransformEnd?.(options, program);
 
-    Tracer.stopProgramTracing()
+    Tracer.stopProgramTracing();
 }
 
-export function runTransformer(prog: Program, state: Es2pandaContextState, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
+export function runTransformer(
+    prog: Program,
+    state: Es2pandaContextState,
+    transform: ProgramTransformer | undefined,
+    pluginContext: PluginContext,
+    hooks: RunTransformerHooks = {}
+) {
     // Program provider used to provide programs to transformer dynamically relative to inserted imports
-    const provider = new ProgramProvider(prog)
+    const provider = new ProgramProvider(prog);
 
     // The first program provided by program provider is the main program
-    let currentProgram = provider.next()
-    let isMainProgram = true
+    let currentProgram = provider.next();
+    let isMainProgram = true;
 
     while (currentProgram) {
         // Options passed to plugin and hooks
         const options: CompilationOptions = {
             isProgramForCodegeneration: isProgramForCodegeneration(currentProgram, isMainProgram),
             state,
-        }
+        };
 
-        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks)
+        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks);
 
         // The first program is always the main program
-        isMainProgram = false
+        isMainProgram = false;
 
         // Proceed to the next program
-        currentProgram = provider.next()
+        currentProgram = provider.next();
     }
 }
 
-function isProgramForCodegeneration(
-    program: Program,
-    isMainProgram: boolean,
-): boolean {
+function isProgramForCodegeneration(program: Program, isMainProgram: boolean): boolean {
     if (!arktsGlobal.isContextGenerateAbcForExternalSourceFiles) {
-        return isMainProgram
+        return isMainProgram;
     }
-    return program.isGenAbcForExternal
+    return program.isGenAbcForExternal;
 }

package/build/libarkts-copy/src/reexport-for-generated.ts

@@ -12,21 +12,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { KNativePointer } from "@koalaui/interop"
-export { AstNode } from "./arkts-api/peers/AstNode"
-export { ArktsObject, isSameNativeObject } from "./arkts-api/peers/ArktsObject"
-export { NodeCache } from "./arkts-api/node-cache"
+export { KNativePointer } from '@koalaui/interop';
+export { AstNode } from './arkts-api/peers/AstNode';
+export { ArktsObject, isSameNativeObject } from './arkts-api/peers/ArktsObject';
+export { NodeCache } from './arkts-api/node-cache';
 export {
     passNode,
     unpackNonNullableNode,
     unpackNodeArray,
     passNodeArray,
+    passStringArray,
     unpackNode,
     unpackString,
     assertValidPeer,
-    updateNodeByNode
-} from "./arkts-api/utilities/private"
-export { nodeByType } from "./arkts-api/class-by-peer"
-export { global } from "./arkts-api/static/global"
-export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums"
-export * from "./arkts-api/utilities/extensions"
+    updateNodeByNode,
+} from './arkts-api/utilities/private';
+export { nodeByType } from './arkts-api/class-by-peer';
+export { global } from './arkts-api/static/global';
+export { Es2pandaMemberExpressionKind } from '../generated/Es2pandaEnums';
+export * from './arkts-api/utilities/extensions';

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

@@ -13,160 +13,166 @@
  * limitations under the License.
  */
 
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { Program } from "./generated"
-import { global } from "./arkts-api/static/global"
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Program } from '../generated';
+import { global } from './arkts-api/static/global';
 
 export class Tracer {
-    static traceDir: string
-    static GlobalTracer: Tracer
-    static Tracers: Map<string, Tracer>
-    static LRUTracer: Tracer | undefined
+    static traceDir: string;
+    static GlobalTracer: Tracer;
+    static Tracers: Map<string, Tracer>;
+    static LRUTracer: Tracer | undefined;
 
     static startGlobalTracing(outDir: string) {
-        Tracer.traceDir = path.join(outDir, 'trace')
-        fs.rmSync(Tracer.traceDir, { force: true, recursive: true })
-        const globalTraceFile = path.join(Tracer.traceDir, '.global.txt')
-        
-        Tracer.GlobalTracer = new Tracer(globalTraceFile)
-        Tracer.pushContext('tracer')
-        traceGlobal(() => `Trace file created at ${globalTraceFile}`, true)
-
-        Tracer.Tracers = new Map<string, Tracer>()
+        Tracer.traceDir = path.join(outDir, 'trace');
+        fs.rmSync(Tracer.traceDir, { force: true, recursive: true });
+        const globalTraceFile = path.join(Tracer.traceDir, '.global.txt');
+
+        Tracer.GlobalTracer = new Tracer(globalTraceFile);
+        Tracer.pushContext('tracer');
+        traceGlobal(() => `Trace file created at ${globalTraceFile}`, true);
+
+        Tracer.Tracers = new Map<string, Tracer>();
     }
 
     static startProgramTracing(program: Program) {
         if (!Tracer.GlobalTracer) {
-            return
+            return;
         }
-        const programPath = program.absoluteName
-        if (programPath == "") {
-            return
+        const programPath = program.absoluteName;
+        if (programPath == '') {
+            return;
         }
-        const suggestedTracer = Tracer.Tracers.get(programPath)
+        const suggestedTracer = Tracer.Tracers.get(programPath);
         if (suggestedTracer) {
-            Tracer.LRUTracer = suggestedTracer
-            return
+            Tracer.LRUTracer = suggestedTracer;
+            return;
         }
         if (!global.arktsconfig) {
-            throw new Error("global.arktsconfig should be set for tracer usage")
+            throw new Error('global.arktsconfig should be set for tracer usage');
         }
-        const relative = path.relative(global.arktsconfig?.baseUrl, programPath)
+        const relative = path.relative(global.arktsconfig?.baseUrl, programPath);
         const traceFileSuggestedPath = relative.startsWith('..')
             ? path.join(this.traceDir, 'external', program.absoluteName.slice(1))
-            : path.join(this.traceDir, relative)
+            : path.join(this.traceDir, relative);
         Tracer.LRUTracer = new Tracer(
-            path.join(path.dirname(traceFileSuggestedPath), path.basename(traceFileSuggestedPath, path.extname(traceFileSuggestedPath)) + '.txt'),
+            path.join(
+                path.dirname(traceFileSuggestedPath),
+                path.basename(traceFileSuggestedPath, path.extname(traceFileSuggestedPath)) + '.txt'
+            ),
             programPath
-        )
+        );
     }
 
     static stopProgramTracing() {
-        Tracer.LRUTracer = undefined
+        Tracer.LRUTracer = undefined;
     }
 
     static stopGlobalTracing() {
-        Tracer.GlobalTracer.traceEventsStats()
+        Tracer.GlobalTracer.traceEventsStats();
     }
 
-    private constructor(private traceFilePath: string, inputFilePath?: string) {
+    private constructor(
+        private traceFilePath: string,
+        inputFilePath?: string
+    ) {
         if (!fs.existsSync(path.dirname(traceFilePath))) {
-            fs.mkdirSync(path.dirname(traceFilePath), { recursive: true })
+            fs.mkdirSync(path.dirname(traceFilePath), { recursive: true });
         }
         if (inputFilePath) {
-            Tracer.Tracers.set(inputFilePath, this)
+            Tracer.Tracers.set(inputFilePath, this);
         }
     }
 
     trace(traceLog: string | undefined | void) {
         if (!traceLog) {
-            return
+            return;
         }
-        const lastContext = Tracer.lastContext()
-        fs.appendFileSync(this.traceFilePath, `[${lastContext.padStart(12)}] ${traceLog}\n`, 'utf-8')
+        const lastContext = Tracer.lastContext();
+        fs.appendFileSync(this.traceFilePath, `[${lastContext.padStart(12)}] ${traceLog}\n`, 'utf-8');
     }
 
-    events: Map<string, number> | undefined
-    eventsPerContext: Map<string, Map<string, number> > | undefined
+    events: Map<string, number> | undefined;
+    eventsPerContext: Map<string, Map<string, number>> | undefined;
 
     recordEvent(event: string) {
         if (!this.events) {
-            this.events = new Map<string, number>()
+            this.events = new Map<string, number>();
         }
-        this.events.set(event, (this.events.get(event) ?? 0) + 1)
+        this.events.set(event, (this.events.get(event) ?? 0) + 1);
 
         if (!this.eventsPerContext) {
-            this.eventsPerContext = new Map<string, Map<string, number> >()
+            this.eventsPerContext = new Map<string, Map<string, number>>();
         }
         if (!this.eventsPerContext.has(Tracer.lastContext())) {
-            this.eventsPerContext.set(Tracer.lastContext(), new Map<string, number>())
+            this.eventsPerContext.set(Tracer.lastContext(), new Map<string, number>());
         }
-        const eventsPerContext = this.eventsPerContext.get(Tracer.lastContext())
-        eventsPerContext?.set(event, (eventsPerContext.get(event) ?? 0) + 1)
+        const eventsPerContext = this.eventsPerContext.get(Tracer.lastContext());
+        eventsPerContext?.set(event, (eventsPerContext.get(event) ?? 0) + 1);
     }
 
     traceEventsStats() {
         if (this.events && this.eventsPerContext) {
             const maxLength = Math.max(
-                ...[...this.events.keys()].map(it => `Event "${it}"`.length),
-                ...[...this.eventsPerContext?.keys()].map(it => `  in context [${it}]`.length),
-            )
-            this.trace(`Events stats:`)
+                ...[...this.events.keys()].map((it) => `Event "${it}"`.length),
+                ...[...this.eventsPerContext?.keys()].map((it) => `  in context [${it}]`.length)
+            );
+            this.trace(`Events stats:`);
             this.events.forEach((eventCnt: number, event: string) => {
-                this.trace(`${`Event "${event}"`.padEnd(maxLength)}: ${eventCnt}`)
+                this.trace(`${`Event "${event}"`.padEnd(maxLength)}: ${eventCnt}`);
                 this.eventsPerContext?.forEach((localizedEventsMap: Map<string, number>, context: string) => {
                     localizedEventsMap.forEach((localizedEventCnt: number, localizedEvent: string) => {
                         if (localizedEvent == event) {
-                            this.trace(`${`  in context [${context}]`.padEnd(maxLength)}: ${localizedEventCnt}`)
+                            this.trace(`${`  in context [${context}]`.padEnd(maxLength)}: ${localizedEventCnt}`);
                         }
-                    })
-                })
-            })
+                    });
+                });
+            });
         } else {
-            this.trace('No events recorded')
+            this.trace('No events recorded');
         }
-        Tracer.popContext()
+        Tracer.popContext();
     }
 
-    private static contexts: string[] = []
+    private static contexts: string[] = [];
 
     static lastContext() {
-        return Tracer.contexts[Tracer.contexts.length - 1]
+        return Tracer.contexts[Tracer.contexts.length - 1];
     }
 
     static pushContext(newContext: string) {
-        Tracer.contexts.push(newContext)
+        Tracer.contexts.push(newContext);
     }
 
     static popContext() {
-        Tracer.contexts.pop()
+        Tracer.contexts.pop();
     }
 }
 
 export function traceGlobal(traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) {
     if (forceLogToConsole) {
-        const result = traceLog()
+        const result = traceLog();
         if (result) {
-            console.log(`[${Tracer.lastContext()}] ${result}`)
+            console.log(`[${Tracer.lastContext()}] ${result}`);
         }
     }
     if (!Tracer.GlobalTracer) {
-        return
+        return;
     }
-    Tracer.GlobalTracer.trace(traceLog())
+    Tracer.GlobalTracer.trace(traceLog());
 }
 
 export function trace(event: string, traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) {
     if (forceLogToConsole) {
-        const result = traceLog()
+        const result = traceLog();
         if (result) {
-            console.log(`[${Tracer.lastContext()}] ${result}`)
+            console.log(`[${Tracer.lastContext()}] ${result}`);
         }
     }
     if (!Tracer.GlobalTracer) {
-        return
+        return;
     }
-    Tracer.LRUTracer?.trace(traceLog())
-    Tracer.GlobalTracer.recordEvent(event)
+    Tracer.LRUTracer?.trace(traceLog());
+    Tracer.GlobalTracer.recordEvent(event);
 }