@idlizer/core 2.1.2 → 2.1.7

package/build/lib/src/idlize.d.ts

@@ -12,10 +12,11 @@ export interface GenerateVisitor<T> {
             tsSourceFile: ts.SourceFile;
             visitor: GenerateVisitor<T>;
             result: T;
+            isAux: boolean;
         };
     }): T;
 }
-export declare function generate<T>(inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare function generate<T>(baseDirs: string[], lookupDirs: string[], inputFiles: string[], auxInputFiles: string[], outputDir: string, stdlibFile: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
 export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
 export declare function isInIdlize(entry: idl.IDLEntry | idl.IDLFile): boolean;
 export declare function isInIdlizeInterop(entry: idl.IDLEntry | idl.IDLFile): boolean;

package/build/lib/src/idlize.js

@@ -16,6 +16,7 @@ import * as ts from "typescript";
 import * as fs from "fs";
 import * as path from "path";
 import * as idl from "./idl";
+import { isDefined } from "./util";
 export function scanDirectory(dir, fileFilter, recursive = false) {
     const dirsToVisit = [path.resolve(dir)];
     const result = [];
@@ -45,7 +46,7 @@ export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = fal
     console.log("Resolved input directories:", resolvedInputDirs);
     return resolvedInputDirs.flatMap(dir => {
         if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
-            console.log(`Processing all .d.ts from directory: ${dir}`);
+            console.log(`Processing all definitions from directory: ${dir}`);
             return scanDirectory(dir, fileFilter, recursive);
         }
         else {
@@ -54,7 +55,10 @@ export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = fal
         }
     });
 }
-export function generate(inputFiles, outputDir, visitorFactory, options) {
+function fileExists(fileName) {
+    return ts.sys.fileExists(fileName);
+}
+export function generate(baseDirs, lookupDirs, inputFiles, auxInputFiles, outputDir, stdlibFile, visitorFactory, options) {
     var _a, _b, _c;
     if (options.enableLog) {
         console.log("Starting generation process...");
@@ -63,24 +67,81 @@ export function generate(inputFiles, outputDir, visitorFactory, options) {
         console.error("Error: No input files specified.");
         process.exit(1);
     }
-    let input = [];
-    if (inputFiles.length > 0) {
-        inputFiles.forEach(file => {
+    let input = new Set;
+    let auxInput = new Set;
+    {
+        const resolveOne = (file, tag) => {
             const fullPath = path.resolve(file);
             if (fs.existsSync(fullPath)) {
-                if (options.enableLog) {
-                    console.log(`Including input file: ${fullPath}`);
-                }
-                input.push(fullPath);
-            }
-            else {
-                console.warn(`Warning: Input file does not exist: ${fullPath}`);
+                if (options.enableLog)
+                    console.log(`Including ${tag} file: ${fullPath}`);
+                return fullPath;
             }
-        });
+            else
+                console.warn(`Warning: ${tag} file does not exist: ${fullPath}`);
+        };
+        inputFiles.map(file => resolveOne(file, "file")).filter(isDefined).sort().map(file => input.add(file));
+        auxInputFiles.map(file => resolveOne(file, "aux file")).filter(isDefined).sort().map(file => auxInput.add(file));
     }
-    input = Array.from(new Set(input.map(p => path.resolve(p)))).sort();
-    let compilerHost = ts.createCompilerHost(options.compilerOptions);
-    let program = ts.createProgram(input.concat([path.join(__dirname, "../stdlib.d.ts")]), options.compilerOptions, compilerHost);
+    const compilerHostBase = ts.createCompilerHost(options.compilerOptions);
+    const compilerHost = Object.assign(Object.assign({}, compilerHostBase), { resolveModuleNames: (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
+            const resolvedModules = [];
+            for (let moduleName of moduleNames) {
+                // TODO: move this replacement table to some external config...
+                {
+                    const replacement = {
+                        "../component/navigation": "@internal/component/ets/navigation",
+                        "wrappedBuilderObject": "@internal/component/ets/common",
+                    };
+                    moduleName = replacement[moduleName] || moduleName;
+                }
+                let result = ts.resolveModuleName(moduleName, containingFile, options, compilerHostBase).resolvedModule;
+                if (result)
+                    resolvedModules.push(result);
+                else {
+                    // as a some fallback - try to resolve from parents of containingFile, lookupDirs
+                    for (let pov of [path.dirname(containingFile), ...lookupDirs]) {
+                        while (!result) {
+                            for (const extension of ["", ".d.ts", ".d.ets"]) {
+                                const candidate = `${moduleName}${extension}`;
+                                if (path.isAbsolute(candidate) && fileExists(candidate)) {
+                                    result = { resolvedFileName: candidate, extension: ts.Extension.Dts, isExternalLibraryImport: false };
+                                    break;
+                                }
+                                const povCandidate = path.join(pov, candidate);
+                                if (fileExists(povCandidate)) {
+                                    result = { resolvedFileName: povCandidate, extension: ts.Extension.Dts, isExternalLibraryImport: false };
+                                    break;
+                                }
+                            }
+                            if (result)
+                                break;
+                            result = ts.resolveModuleName(path.join(pov, moduleName), containingFile, options, compilerHostBase).resolvedModule;
+                            if (result)
+                                break;
+                            result = ts.resolveModuleName(moduleName, pov, options, compilerHostBase).resolvedModule;
+                            if (result)
+                                break;
+                            const nextPov = path.resolve(pov, "..");
+                            if (nextPov == pov)
+                                break;
+                            if (baseDirs.every(baseDir => path.relative(baseDir, nextPov).startsWith("..")))
+                                break;
+                            pov = nextPov;
+                        }
+                        if (result)
+                            break;
+                    }
+                    if (!result)
+                        console.warn(`Dts import at '${containingFile}', module '${moduleName}': unable to resolve source file path`);
+                    resolvedModules.push(result);
+                }
+            }
+            return resolvedModules;
+        } });
+    if (!fs.existsSync(stdlibFile))
+        throw new Error("Unable to find stdlib.d.ts");
+    const program = ts.createProgram([...input.values(), ...auxInput.values(), stdlibFile], options.compilerOptions, compilerHost);
     if (options.enableLog) {
         console.log("Initialized TypeScript program with input files:", input);
     }
@@ -91,15 +152,9 @@ export function generate(inputFiles, outputDir, visitorFactory, options) {
     const dtsFileName2Visitor = {};
     for (const sourceFile of program.getSourceFiles()) {
         const resolvedSourceFileName = path.resolve(sourceFile.fileName);
-        const isExplicitFile = input.some(f => path.resolve(f) === resolvedSourceFileName);
-        if (!isExplicitFile) {
-            if (options.enableLog) {
-                console.log(`Skipping file: ${resolvedSourceFileName}`);
-            }
-            continue;
-        }
+        const isAux = !input.has(resolvedSourceFileName);
         if (options.enableLog) {
-            console.log(`Processing file: ${resolvedSourceFileName}`);
+            console.log(`Processing ${isAux ? "aux " : ""}file: ${resolvedSourceFileName}`);
         }
         // Walk the tree to search for classes
         const visitor = visitorFactory(sourceFile, program, compilerHost);
@@ -107,7 +162,8 @@ export function generate(inputFiles, outputDir, visitorFactory, options) {
         dtsFileName2Visitor[sourceFile.fileName] = {
             tsSourceFile: sourceFile,
             visitor,
-            result
+            result,
+            isAux: isAux
         };
     }
     for (const resolvedSourceFileName in dtsFileName2Visitor) {
@@ -117,7 +173,7 @@ export function generate(inputFiles, outputDir, visitorFactory, options) {
     }
     for (const resolvedSourceFileName in dtsFileName2Visitor) {
         const visitorStaff = dtsFileName2Visitor[resolvedSourceFileName];
-        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, visitorStaff.result, outputDir, visitorStaff.tsSourceFile);
+        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, visitorStaff.result, outputDir, visitorStaff.tsSourceFile, visitorStaff.isAux);
     }
     (_c = options.onEnd) === null || _c === void 0 ? void 0 : _c.call(options, outputDir);
     if (options.enableLog) {

package/build/lib/src/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./config";
 export * from "./idl";
+export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
 export * from "./idlize";
@@ -46,8 +47,8 @@ export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
-export { fromIDL } from "./from-idl/common";
+export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
-export { D, ConfigTypeInfer, ConfigSchema } from './configDescriber';
+export { toIDLFile, addSyntheticType, resolveSyntheticType, IDLTokenInfoMap } from "./from-idl/deserialize";
+export { D, ConfigTypeInfer, ConfigSchema, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -14,6 +14,7 @@
  */
 export * from "./config";
 export * from "./idl";
+export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
 export * from "./idlize";
@@ -60,8 +61,8 @@ export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
-export { fromIDL } from "./from-idl/common";
+export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
 export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
-export { D } from './configDescriber';
+export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map

package/build/lib/src/options.d.ts

@@ -2,7 +2,7 @@ import * as ts from "typescript";
 export interface GenerateOptions<T> {
     compilerOptions: ts.CompilerOptions;
     onBegin?: (outDir: string, typeChecker: ts.TypeChecker) => void;
-    onSingleFile?: (entries: T, outDir: string, inputFile: ts.SourceFile) => void;
+    onSingleFile?: (entries: T, outDir: string, inputFile: ts.SourceFile, isAux: boolean) => void;
     onEnd?: (outDir: string) => void;
     enableLog?: boolean;
     recursive?: boolean;

package/build/lib/src/peer-generation/BuilderClass.d.ts

@@ -16,7 +16,5 @@ export declare class BuilderClass {
  * Builder classes are classes with methods which have only one parameter and return only itself
  */
 export declare function isBuilderClass(declaration: IDLInterface): boolean;
-export declare const CUSTOM_BUILDER_CLASSES: BuilderClass[];
-export declare function isCustomBuilderClass(name: string): boolean;
 export declare function methodsGroupOverloads(methods: Method[]): Method[][];
 //# sourceMappingURL=BuilderClass.d.ts.map

package/build/lib/src/peer-generation/BuilderClass.js

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 import { generatorConfiguration } from "../config";
-import { isDefined } from "../util";
 export class BuilderClass {
     constructor(declaration, name, generics, isInterface, superClass, fields, constructors, methods, needBeGenerated = true) {
         this.declaration = declaration;
@@ -35,9 +34,6 @@ export function isBuilderClass(declaration) {
     if (generatorConfiguration().builderClasses.includes(className)) {
         return true;
     }
-    if (isCustomBuilderClass(className)) {
-        return true;
-    }
     // TBD: update builder class check condition.
     // Only SubTabBarStyle, BottomTabBarStyle, DotIndicator, and DigitIndicator classes
     // are used for now.
@@ -58,10 +54,6 @@ export function isBuilderClass(declaration) {
     return methods.every(it => it.type && className == it.type.getText() && it.parameters.length === 1)
     */
 }
-export const CUSTOM_BUILDER_CLASSES = [];
-export function isCustomBuilderClass(name) {
-    return isDefined(CUSTOM_BUILDER_CLASSES.find(it => it.name === name));
-}
 export function methodsGroupOverloads(methods) {
     const seenNames = new Set();
     const groups = [];

package/build/lib/src/peer-generation/LayoutManager.d.ts

@@ -2,15 +2,22 @@ import { IDLEntry } from "../idl";
 export declare enum LayoutNodeRole {
     PEER = 0,
     INTERFACE = 1,
-    GLOBAL = 2
+    GLOBAL = 2,
+    COMPONENT = 3
+}
+export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function';
+export interface LayoutTargetDescription {
+    node: IDLEntry;
+    role: LayoutNodeRole;
+    hint?: LayoutTargetDescriptionHint;
 }
 export interface LayoutManagerStrategy {
-    resolve(node: IDLEntry, role: LayoutNodeRole): string;
+    resolve(target: LayoutTargetDescription): string;
 }
 export declare class LayoutManager {
     private strategy;
     constructor(strategy: LayoutManagerStrategy);
-    resolve(node: IDLEntry, role: LayoutNodeRole): string;
+    resolve(target: LayoutTargetDescription): string;
     static Empty(): LayoutManager;
 }
 //# sourceMappingURL=LayoutManager.d.ts.map

package/build/lib/src/peer-generation/LayoutManager.js

@@ -17,13 +17,14 @@ export var LayoutNodeRole;
     LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
     LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
     LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
+    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
 })(LayoutNodeRole || (LayoutNodeRole = {}));
 export class LayoutManager {
     constructor(strategy) {
         this.strategy = strategy;
     }
-    resolve(node, role) {
-        return this.strategy.resolve(node, role);
+    resolve(target) {
+        return this.strategy.resolve(target);
     }
     ////////////////////////////////////////////////////////////////////
     static Empty() {

package/build/lib/src/peer-generation/Materialized.d.ts

@@ -59,6 +59,6 @@ export declare class MaterializedClass implements PeerClassBase {
 }
 export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod | undefined;
 export declare function getInternalClassName(name: string): string;
-export declare function getInternalClassQualifiedName(target: idl.IDLEntry): string;
+export declare function getInternalClassQualifiedName(target: idl.IDLEntry, pattern?: idl.QNPattern): string;
 export declare function getMaterializedFileName(name: string): string;
 //# sourceMappingURL=Materialized.d.ts.map

package/build/lib/src/peer-generation/Materialized.js

@@ -135,13 +135,13 @@ export function createDestroyPeerMethod(clazz) {
     if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
-    return new MaterializedMethod(clazz.className, clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.className)], ['peer'])));
+    return new MaterializedMethod(idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
 export function getInternalClassName(name) {
     return `${name}Internal`;
 }
-export function getInternalClassQualifiedName(target) {
-    return getInternalClassName(qualifiedName(target, "."));
+export function getInternalClassQualifiedName(target, pattern = "package.namespace.name") {
+    return getInternalClassName(qualifiedName(target, ".", pattern));
 }
 export function getMaterializedFileName(name) {
     const pascalCase = name.split('_').map(x => capitalize(x)).join('');

package/build/lib/src/peer-generation/PeerClass.d.ts

@@ -1,15 +1,14 @@
-import { IDLProperty } from "../idl";
+import { IDLFile, IDLProperty } from "../idl";
 import { PeerMethod } from "./PeerMethod";
-import { PeerFile } from "./PeerFile";
 export interface PeerClassBase {
     generatedName(isCallSignature: boolean): string;
     getComponentName(): string;
 }
 export declare class PeerClass implements PeerClassBase {
-    readonly file: PeerFile;
+    readonly file: IDLFile;
     readonly componentName: string;
     readonly originalFilename: string;
-    constructor(file: PeerFile, componentName: string, originalFilename: string);
+    constructor(file: IDLFile, componentName: string, originalFilename: string);
     generatedName(isCallSignature: boolean): string;
     getComponentName(): string;
     methods: PeerMethod[];
@@ -19,10 +18,6 @@ export declare class PeerClass implements PeerClassBase {
     originalParentFilename: string | undefined;
     parentComponentName: string | undefined;
     attributesFields: IDLProperty[];
-    attributesTypes: {
-        typeName: string;
-        content: string;
-    }[];
     hasGenericType: boolean;
 }
 export declare function createConstructPeerMethod(clazz: PeerClass): PeerMethod;

package/build/lib/src/peer-generation/PeerClass.js

@@ -28,7 +28,6 @@ export class PeerClass {
         this.originalParentFilename = undefined;
         this.parentComponentName = undefined;
         this.attributesFields = [];
-        this.attributesTypes = [];
         this.hasGenericType = false;
     }
     generatedName(isCallSignature) {

package/build/lib/src/peer-generation/PeerFile.d.ts

@@ -1,7 +1,6 @@
 import * as idl from '../idl';
 import { PeerClass } from "./PeerClass";
-import { LibraryFileInterface } from '../LibraryInterface';
-export declare class PeerFile implements LibraryFileInterface {
+export declare class PeerFile1 {
     readonly file: idl.IDLFile;
     readonly peers: Map<string, PeerClass>;
     constructor(file: idl.IDLFile);

package/build/lib/src/peer-generation/PeerFile.js

@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export class PeerFile {
+export class PeerFile1 {
     constructor(file) {
         this.file = file;
         this.peers = new Map();

package/build/lib/src/peer-generation/PeerLibrary.d.ts

@@ -6,7 +6,6 @@ import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from '../LibraryInterface';
 import { BuilderClass } from './BuilderClass';
 import { MaterializedClass } from './Materialized';
-import { PeerFile } from './PeerFile';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
 export interface GlobalScopeDeclarations {
@@ -10253,6 +10252,7 @@ export declare const lenses: {
 };
 export declare class PeerLibrary implements LibraryInterface {
     language: Language;
+    readonly useMemoM3: boolean;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
@@ -10260,12 +10260,13 @@ export declare class PeerLibrary implements LibraryInterface {
     private _syntheticFile;
     initSyntheticEntries(file: idl.IDLFile): void;
     getSyntheticData(): idl.IDLInterface[];
-    readonly files: PeerFile[];
+    readonly files: idl.IDLFile[];
+    readonly auxFiles: idl.IDLFile[];
     readonly builderClasses: Map<string, BuilderClass>;
     get buildersToGenerate(): BuilderClass[];
     readonly materializedClasses: Map<string, MaterializedClass>;
     get materializedToGenerate(): MaterializedClass[];
-    constructor(language: Language);
+    constructor(language: Language, useMemoM3?: boolean);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
@@ -10278,10 +10279,15 @@ export declare class PeerLibrary implements LibraryInterface {
     private context;
     getCurrentContext(): string | undefined;
     setCurrentContext(context: string | undefined): void;
-    findFileByOriginalFilename(filename: string): PeerFile | undefined;
+    findFileByOriginalFilename(filename: string): idl.IDLFile | undefined;
     mapType(type: idl.IDLType): string;
-    resolveTypeReference(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-    private resolveTypeReferenceScoped;
+    private referenceCache;
+    enableCache(): void;
+    resolveTypeReference(type: idl.IDLReferenceType, singleStep?: boolean): idl.IDLEntry | undefined;
+    private _useFallback;
+    disableFallback(): void;
+    resolveNamedNode(target: string[], pov?: idl.IDLNode | undefined): idl.IDLEntry | undefined;
+    resolveImport(target: idl.IDLImport): idl.IDLEntry | undefined;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     private customConvertor;
@@ -10292,7 +10298,6 @@ export declare class PeerLibrary implements LibraryInterface {
 export declare const ArkInt32: idl.IDLPrimitiveType;
 export declare const ArkInt64: idl.IDLPrimitiveType;
 export declare const ArkFunction: idl.IDLPrimitiveType;
-export declare const ArkLength: idl.IDLPrimitiveType;
 export declare const ArkDate: idl.IDLPrimitiveType;
 export declare const ArkCustomObject: idl.IDLPrimitiveType;
 export declare function cleanPrefix(name: string, prefix: string): string;