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

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

@@ -13,58 +13,231 @@
  * limitations under the License.
  */
 
-import { Es2pandaContextState } from "../generated/Es2pandaEnums"
-import { Program } from "../generated"
-import { ExternalSource } from "./peers/ExternalSource"
-import { KNativePointer } from "@koalaui/interop"
-import { global } from "./static/global"
-import { RunTransformerHooks } from "../plugin-utils"
+import { Es2pandaContextState } from '../../generated/Es2pandaEnums';
+import { ETSModule, Program } from '../../generated';
+import { ExternalSource } from './peers/ExternalSource';
+import { KNativePointer, nullptr } from '@koalaui/interop';
+import { global } from './static/global';
+import { RunTransformerHooks } from '../plugin-utils';
+import { Context } from './peers/Context';
 
 export interface CompilationOptions {
-    readonly isProgramForCodegeneration: boolean,
-    readonly state: Es2pandaContextState,
+    readonly isProgramForCodegeneration: boolean;
+    readonly state: Es2pandaContextState;
 }
 
-export interface PluginContext {
-    setParameter<V>(name: string, value: V): void
-    parameter<V>(name: string) : V | undefined
+export interface DependentModuleConfig {
+    packageName: string;
+    moduleName: string;
+    moduleType: string;
+    modulePath: string;
+    sourceRoots: string[];
+    entryFile: string;
+    language: string;
+    declFilesPath?: string;
+    dependencies?: string[];
 }
 
-export class PluginContextImpl implements PluginContext {
-    map = new Map<String, Object|undefined>()
-    parameter<V>(name: string): V|undefined {
-        return this.map.get(name) as (V|undefined)
+export interface ProjectConfig {
+    bundleName: string;
+    moduleName: string;
+    cachePath: string;
+    dependentModuleList: DependentModuleConfig[];
+    appResource: string;
+    rawFileResource: string;
+    buildLoaderJson: string;
+    hspResourcesMap: boolean;
+    compileHar: boolean;
+    byteCodeHar: boolean;
+    uiTransformOptimization: boolean;
+    resetBundleName: boolean;
+    allowEmptyBundleName: boolean;
+    moduleType: string;
+    moduleRootPath: string;
+    aceModuleJsonPath: string;
+    ignoreError: boolean;
+    projectPath: string;
+    projectRootPath: string;
+    integratedHsp: boolean;
+    frameworkMode?: string;
+    isUi2abc?: boolean;
+}
+
+export interface PluginContextBase {
+    setParameter<V>(name: string, value: V): void;
+    parameter<V>(name: string): V | undefined;
+}
+
+export interface PluginContext extends PluginContextBase {
+    /**
+     * @deprecated
+     */
+    setArkTSProgram(program: Program): void
+
+    /**
+     * @deprecated
+     */
+    getArkTSProgram(): Program | undefined
+
+    setCodingFilePath(codingFilePath: string): void
+
+    getCodingFilePath(): string | undefined
+
+    isCoding(): boolean
+}
+
+
+export class PluginContextBaseImpl implements PluginContextBase {
+    map = new Map<string, object | undefined>();
+
+    parameter<V>(name: string): V | undefined {
+        return this.map.get(name) as V | undefined;
     }
-    setParameter<V>(name: string, value: V) {
-        this.map.set(name, value as Object)
+    setParameter<V>(name: string, value: V): void {
+        this.map.set(name, value as object);
     }
 }
 
-export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions, context: PluginContext) => void
+// Temporary hack to use plugin context's parameters when compiling with driver
+export function extendPluginContext(context: PluginContextImpl) {
+    if (typeof context.setParameter == "function") {
+        return
+    }
+    const pluginContextBaseImpl = new PluginContextBaseImpl()
+    context.map = pluginContextBaseImpl.map
+    context.setParameter = pluginContextBaseImpl.setParameter
+    context.parameter = pluginContextBaseImpl.parameter
+}
+
+export class PluginContextImpl extends PluginContextBaseImpl implements PluginContext {
+    private ast: ETSModule | undefined;
+    private projectConfig: ProjectConfig | undefined;
+
+    private program: Program | undefined;
+    private codingFilePath: string | undefined;
+
+    setContextPtr(ptr: KNativePointer): void {
+        if (!global.compilerContext) {
+            global.compilerContext = new Context(ptr);
+        } else {
+            global.compilerContext.peer = ptr;
+        }
+    }
+
+    getContextPtr(): KNativePointer {
+        return global.compilerContext?.peer ?? nullptr;
+    }
+
+    public setProjectConfig(projectConfig: ProjectConfig): void {
+        this.projectConfig = projectConfig;
+    }
+
+    public getProjectConfig(): ProjectConfig | undefined {
+        return this.projectConfig;
+    }
+    /**
+     * @deprecated
+     */
+    public setArkTSAst(ast: ETSModule): void {
+        this.ast = ast;
+    }
+
+    /**
+     * @deprecated
+     */
+    public getArkTSAst(): ETSModule | undefined {
+        return this.ast;
+    }
+
+    /**
+     * @deprecated
+     */
+    public setArkTSProgram(program: Program): void {
+        this.program = program;
+    }
+
+    /**ProjectConfig
+     * @deprecated
+     */
+    public getArkTSProgram(): Program | undefined {
+        return this.program;
+    }
+
+    public setCodingFilePath(codingFilePath: string): void {
+        this.codingFilePath = codingFilePath;
+    }
+
+    public getCodingFilePath(): string | undefined {
+        return this.codingFilePath;
+    }
+
+    public isCoding(): boolean {
+        return this.codingFilePath !== undefined;
+    }
+}
+
+export type PluginHandlerFunction = () => void;
+
+export type PluginHandlerObject = {
+    order: 'pre' | 'post' | undefined;
+    handler: PluginHandlerFunction;
+};
+
+export type PluginHandler = PluginHandlerFunction | PluginHandlerObject;
+
+export type ProgramTransformer = (
+    program: Program,
+    compilationOptions: CompilationOptions,
+    context: PluginContext
+) => void;
+
+export interface Plugins {
+    name: string;
+    afterNew?: PluginHandler;
+    parsed?: PluginHandler;
+    scopeInited?: PluginHandler;
+    checked?: PluginHandler;
+    lowered?: PluginHandler;
+    asmGenerated?: PluginHandler;
+    binGenerated?: PluginHandler;
+    clean?: PluginHandler;
+}
+
+export type PluginState = keyof Omit<Plugins, 'name'>;
+
+export type PluginExecutor = {
+    name: string;
+    handler: PluginHandlerFunction;
+};
+
+export interface BuildConfig {
+    compileFiles: string[];
+}
+
 
-export function defaultFilter(name: string) {
-    if (name.startsWith("std.")) return false
-    if (name.startsWith("escompat")) return false
-    return true
+export function defaultFilter(name: string): boolean {
+    if (name.startsWith('std.')) return false;
+    if (name.startsWith('escompat')) return false;
+    return true;
 }
 
 export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): Program[] {
     return [
         program,
-        ...program.getExternalSources().flatMap((it: ExternalSource) => {
+        ...program.getExternalSources().flatMap((it: ExternalSource): Program[] => {
             if (filter(it.getName())) {
-                return it.programs
+                return it.programs;
             }
-            return []
-        })
-    ]
+            return [];
+        }),
+    ];
 }
 
 export interface PluginEntry {
-    name?: string
-    parsed?: (hooks?: RunTransformerHooks) => void
-    checked?: (hooks?: RunTransformerHooks) => void
-    clean?: (hooks?: RunTransformerHooks) => void
+    name?: string;
+    parsed?: (hooks?: RunTransformerHooks) => void;
+    checked?: (hooks?: RunTransformerHooks) => void;
+    clean?: (hooks?: RunTransformerHooks) => void;
 }
 
-export type PluginInitializer = (parsedJson?: Object, checkedJson?: Object) => PluginEntry
+export type PluginInitializer = (parsedJson?: object, checkedJson?: object) => PluginEntry;

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

@@ -13,95 +13,94 @@
  * limitations under the License.
  */
 
-import { throwError } from "../../utils"
-import { KNativePointer, nullptr } from "@koalaui/interop"
-import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../../Es2pandaNativeModule"
-import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule"
-import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
-import { Context } from "../peers/Context"
-import { Profiler } from "./profiler"
-import { ArkTsConfig } from "../../generated"
+import { throwError } from '../../utils';
+import { KNativePointer, nullptr } from '@koalaui/interop';
+import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from '../../Es2pandaNativeModule';
+import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from '../../../generated/Es2pandaNativeModule';
+import { initInterop, InteropNativeModule } from '../../InteropNativeModule';
+import { Context } from '../peers/Context';
+import { Profiler } from './profiler';
+import { ArkTsConfig } from '../../../generated';
 import { Config } from '../peers/Config';
 
 export class UpdateTracker {
-    stack: boolean[] = []
+    stack: boolean[] = [];
 
     push() {
-        this.stack.push(false)
+        this.stack.push(false);
     }
 
     update() {
-        this.stack[this.stack.length - 1] = true
+        this.stack[this.stack.length - 1] = true;
     }
 
     check() {
-        return this.stack.pop()
+        return this.stack.pop();
     }
 }
 
 export class global {
-    public static filePath: string = "./plugins/input/main.ets"
+    public static filePath: string = './plugins/input/main.ets';
 
-    public static arktsconfig?: ArkTsConfig
+    public static arktsconfig?: ArkTsConfig;
     public static configObj?: Config;
 
-    private static _config?: KNativePointer
+    private static _config?: KNativePointer;
     public static set config(config: KNativePointer) {
-        global._config = config
+        global._config = config;
         global.configObj = new Config(global._config);
     }
     public static get config(): KNativePointer {
-        return global._config ?? throwError('Global.config not initialized')
+        return global._config ?? throwError('Global.config not initialized');
     }
     public static configIsInitialized(): boolean {
-        return global._config !== undefined && global._config !== nullptr
+        return !!global._config && global._config !== nullptr;
     }
     public static resetConfig(): void {
-        global._config = undefined
+        global._config = undefined;
         global.configObj = undefined;
     }
 
     // Improve: 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');
     }
 
     // Improve: rename to context when the pointer valued one is eliminated
-    public static compilerContext: Context | undefined
-    public static isContextGenerateAbcForExternalSourceFiles: boolean = false
+    public static compilerContext: Context | undefined;
+    public static isContextGenerateAbcForExternalSourceFiles: boolean = false;
 
-    private static _es2panda: Es2pandaNativeModule | undefined = undefined
+    private static _es2panda: Es2pandaNativeModule | undefined = undefined;
     public static get es2panda(): Es2pandaNativeModule {
         if (this._es2panda === undefined) {
-            this._es2panda = initEs2panda()
+            this._es2panda = initEs2panda();
         }
-        return this._es2panda
+        return this._es2panda;
     }
 
-    private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined
+    private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined;
     public static get generatedEs2panda(): GeneratedEs2pandaNativeModule {
         if (this._generatedEs2panda === undefined) {
-            this._generatedEs2panda = initGeneratedEs2panda()
+            this._generatedEs2panda = initGeneratedEs2panda();
         }
-        return this._generatedEs2panda
+        return this._generatedEs2panda;
     }
 
-    private static _interop: InteropNativeModule | undefined = undefined
+    private static _interop: InteropNativeModule | undefined = undefined;
     public static get interop(): InteropNativeModule {
-        if (this._interop === undefined) this._interop = initInterop()
-        return this._interop
-
+        if (this._interop === undefined) this._interop = initInterop();
+        return this._interop;
     }
 
-    public static profiler = new Profiler()
+    public static profiler = new Profiler();
 
     // Check node type values during node creation
-    public static validatePeerTypes = false
+    public static validatePeerTypes = false;
 
     public static clearContext(): void {
-        global.compilerContext = undefined
+        global.compilerContext = undefined;
     }
 
     // Keep track of update info to optimize performance
-    public static updateTracker: UpdateTracker = new UpdateTracker()
+    public static updateTracker: UpdateTracker = new UpdateTracker();
 }

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

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop";
-import { Context } from "../peers/Context";
-import { global } from "./global";
-import { NodeCache } from "../node-cache"
+import { KNativePointer } from '@koalaui/interop';
+import { Context } from '../peers/Context';
+import { global } from './global';
+import { NodeCache } from '../node-cache';
 
 export function getOrUpdateGlobalContext(peer: KNativePointer): Context {
     if (!global.compilerContext || global.context !== peer) {
@@ -24,4 +24,4 @@ export function getOrUpdateGlobalContext(peer: KNativePointer): Context {
         global.compilerContext = new Context(peer);
     }
     return global.compilerContext;
-}
+}