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

package/build/lib/src/index.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -17,11 +17,10 @@ export * from "./idl";
 export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
-export * from "./idlize";
 export * from "./inheritance";
+export * from "./inputPaths";
 export * from "./Language";
 export * from "./languageSpecificKeywords";
-export * from "./options";
 export * from "./util";
 export * from "./rand_utils";
 export * from "./IndentedPrinter";
@@ -36,14 +35,12 @@ export * from "./LanguageWriters/nameConvertor";
 export * from "./LanguageWriters/convertors/CppConvertors";
 export * from "./LanguageWriters/convertors/TSConvertors";
 export * from "./LanguageWriters/convertors/ETSConvertors";
-export * from "./LanguageWriters/convertors/JavaConvertors";
 export * from "./LanguageWriters/convertors/CJConvertors";
 export * from "./LanguageWriters/convertors/InteropConvertors";
 export * from "./LanguageWriters/convertors/KotlinConvertors";
 export * from "./LanguageWriters/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
-export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
 export * from "./LanguageWriters/writers/KotlinLanguageWriter";
@@ -55,7 +52,6 @@ export * from "./peer-generation/PeerLibrary";
 export * from "./peer-generation/PeerFile";
 export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
-export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
@@ -63,17 +59,20 @@ export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
+export * from "./peer-generation/ConflictingDeclarations";
+export * from "./peer-generation/toDeclaration";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";
 export * from "./transformers/OnSerializeTransformer";
+export * from "./transformers/IdlTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { parseIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { parseIDLFile, addSyntheticType, resolveSyntheticType, compareNodes, toIdlType } from "./from-idl/deserialize";
 export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
-import * as ts from "typescript";
 export declare enum InheritanceRole {
     Finalizable = 0,
     PeerNode = 1,
@@ -6,7 +5,6 @@ export declare enum InheritanceRole {
     Heir = 3,
     Standalone = 4
 }
-export declare function isCommonMethodOrSubclass(typeChecker: ts.TypeChecker, decl: ts.ClassDeclaration): boolean;
 export declare function determineInheritanceRole(name: string): InheritanceRole;
 export declare function determineParentRole(name: string | undefined, parent: string | undefined): InheritanceRole;
 export declare function isCommonMethod(name: string): boolean;

package/build/lib/src/inheritance.js

@@ -12,9 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as ts from "typescript";
 import { generatorConfiguration } from "./config";
-import { asString, heritageDeclarations, identName } from "./util";
 export var InheritanceRole;
 (function (InheritanceRole) {
     InheritanceRole[InheritanceRole["Finalizable"] = 0] = "Finalizable";
@@ -23,21 +21,6 @@ export var InheritanceRole;
     InheritanceRole[InheritanceRole["Heir"] = 3] = "Heir";
     InheritanceRole[InheritanceRole["Standalone"] = 4] = "Standalone";
 })(InheritanceRole || (InheritanceRole = {}));
-export function isCommonMethodOrSubclass(typeChecker, decl) {
-    var _a;
-    let name = identName(decl.name);
-    let isSubclass = isRoot(name);
-    (_a = decl.heritageClauses) === null || _a === void 0 ? void 0 : _a.forEach(it => {
-        heritageDeclarations(typeChecker, it).forEach(it => {
-            let name = asString(it.name);
-            isSubclass = isSubclass || isRoot(name);
-            if (!ts.isClassDeclaration(it))
-                return isSubclass;
-            isSubclass = isSubclass || isCommonMethodOrSubclass(typeChecker, it);
-        });
-    });
-    return isSubclass;
-}
 export function determineInheritanceRole(name) {
     if (generatorConfiguration().rootComponents.includes(name))
         return InheritanceRole.Root;

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

@@ -0,0 +1,11 @@
+export type InputPaths = {
+    baseDirs: string[];
+    inputDirs: string[];
+    auxInputDirs: string[];
+    inputFiles: string[];
+    auxInputFiles: string[];
+    libraryPackages: string[];
+};
+export declare function formatInputPaths(options: any): InputPaths;
+export declare function validatePaths(paths: string[], type: 'file' | 'dir'): void;
+//# sourceMappingURL=inputPaths.d.ts.map

package/build/lib/src/inputPaths.js

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 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.
+ */
+import * as fs from "fs";
+import * as path from "path";
+function processInputOption(option) {
+    if (typeof option === 'undefined') {
+        return [];
+    }
+    else if (typeof option === 'string') {
+        return option.split(',')
+            .map(item => item.trim())
+            .filter(Boolean);
+    }
+    else {
+        return option.flatMap(processInputOption);
+    }
+}
+// iterate through files in the same order even if input order changes
+function sortFiles(files) {
+    return files.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+}
+export function formatInputPaths(options) {
+    if (options.inputFiles) {
+        options.inputFiles = processInputOption(options.inputFiles);
+    }
+    if (options.auxInputFiles) {
+        options.auxInputFiles = processInputOption(options.auxInputFiles);
+    }
+    if (options.inputDir) {
+        options.inputDir = processInputOption(options.inputDir);
+    }
+    if (options.auxInputDir) {
+        options.auxInputDir = processInputOption(options.auxInputDir);
+    }
+    if (options.libraryPackages) {
+        options.libraryPackages = processInputOption(options.libraryPackages);
+    }
+    const inputDirs = options.inputDir || [];
+    const auxInputDirs = options.auxInputDir || [];
+    const inputFiles = options.inputFiles || [];
+    const auxInputFiles = options.auxInputFiles || [];
+    const libraryPackages = options.libraryPackages || [];
+    let baseDirs = options.baseDir ? processInputOption(options.baseDir) : inputDirs;
+    if (!baseDirs.length && inputFiles.length) {
+        baseDirs = [...(new Set(options.inputFiles.map((it) => path.dirname(it))).values())];
+    }
+    if (!baseDirs.length)
+        throw new Error("Check your --base-dir parameter, value is missing");
+    return {
+        baseDirs,
+        inputDirs,
+        auxInputDirs,
+        inputFiles: sortFiles(inputFiles),
+        auxInputFiles: sortFiles(auxInputFiles),
+        libraryPackages
+    };
+}
+export function validatePaths(paths, type) {
+    paths.forEach(pathItem => {
+        if (!fs.existsSync(pathItem)) {
+            console.error(`Input ${type} does not exist: ${pathItem}`);
+            process.exit(1);
+        }
+        else {
+            console.log(`Input ${type} exists: ${pathItem}`);
+        }
+    });
+}
+//# sourceMappingURL=inputPaths.js.map

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

@@ -1,5 +1,4 @@
 export declare const cppKeywords: Set<string>;
 export declare const CJKeywords: Set<string>;
-export declare const IDLKeywords: Set<string>;
 export declare const TSKeywords: Set<string>;
 //# sourceMappingURL=languageSpecificKeywords.d.ts.map

package/build/lib/src/languageSpecificKeywords.js

@@ -40,11 +40,6 @@ export const CJKeywords = new Set([
     'open', 'operator', 'foreign', 'inout',
     'prop', 'mut', 'unsafe', 'get', 'set', 'type'
 ]);
-export const IDLKeywords = new Set([
-    "attribute", "callback", "object", "toString",
-    'sequence', 'record', 'or', 'Int8Array',
-    'interface', 'number', 'undefined'
-]);
 export const TSKeywords = new Set([
     "namespace"
 ]);

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

@@ -0,0 +1,6 @@
+import * as idl from "../idl";
+import { Language } from "../Language";
+import { LibraryInterface } from "../LibraryInterface";
+export declare function findTopLevelConflicts(library: LibraryInterface, language: Language): string[];
+export declare function isTopLevelConflicted(library: LibraryInterface, language: Language, node: idl.IDLEntry): boolean;
+//# sourceMappingURL=ConflictingDeclarations.d.ts.map

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

@@ -0,0 +1,43 @@
+import * as idl from "../idl";
+import { Language } from "../Language";
+const findTopLevelConflicts_cache = new Map();
+export function findTopLevelConflicts(library, language) {
+    if (!findTopLevelConflicts_cache.has(library))
+        findTopLevelConflicts_cache.set(library, new Map);
+    const libraryCache = findTopLevelConflicts_cache.get(library);
+    if (!libraryCache.has(language))
+        libraryCache.set(language, findTopLevelConflictsUncached(library, language));
+    return libraryCache.get(language);
+}
+function findTopLevelConflictsUncached(library, language) {
+    const foundNames = new Set();
+    const conflictingNames = new Set();
+    const ignoreTypedefs = language === Language.CPP;
+    for (const file of library.files) {
+        for (const entry of file.entries) {
+            if (idl.isSyntheticEntry(entry))
+                continue;
+            if (ignoreTypedefs && idl.isTypedef(entry))
+                // for redefinitions like `typedef _Resource Resource;` - in CPP than anyway will be expanded to Resource declaration
+                continue;
+            if (idl.isCallback(entry) || idl.isInterface(entry) || idl.isTypedef(entry) || idl.isEnum(entry)) {
+                if (foundNames.has(entry.name)) {
+                    conflictingNames.add(entry.name);
+                }
+                else {
+                    foundNames.add(entry.name);
+                }
+            }
+        }
+    }
+    return Array.from(conflictingNames);
+}
+export function isTopLevelConflicted(library, language, node) {
+    const topLevelConflicts = findTopLevelConflicts(library, language);
+    while (node.parent && idl.isNamespace(node.parent)) {
+        node = node.parent;
+    }
+    return node.parent !== undefined
+        && idl.isFile(node.parent) && idl.isEntry(node) && topLevelConflicts.includes(node.name);
+}
+//# sourceMappingURL=ConflictingDeclarations.js.map

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

@@ -6,7 +6,7 @@ export declare enum LayoutNodeRole {
     COMPONENT = 3,
     SERIALIZER = 4
 }
-export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier';
+export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier' | 'component.handwritten';
 export interface LayoutTargetDescription {
     node: IDLEntry;
     role: LayoutNodeRole;
@@ -23,4 +23,6 @@ export declare class LayoutManager {
     handwrittenPackage(): string;
     static Empty(): LayoutManager;
 }
+export declare function wrapCurrentFileDescription<T>(description: LayoutTargetDescription, op: () => T): T;
+export declare function isDeclaredInCurrentFile(layout: LayoutManagerStrategy, over: LayoutTargetDescription): boolean;
 //# sourceMappingURL=LayoutManager.d.ts.map

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

@@ -35,4 +35,19 @@ export class LayoutManager {
         return new LayoutManager({ resolve: () => '', handwrittenPackage: () => '' });
     }
 }
+let currentGenerationDescription;
+export function wrapCurrentFileDescription(description, op) {
+    const prev = currentGenerationDescription;
+    currentGenerationDescription = description;
+    const result = op();
+    currentGenerationDescription = prev;
+    return result;
+}
+export function isDeclaredInCurrentFile(layout, over) {
+    if (!currentGenerationDescription)
+        throw new Error("Current file context is not set up. Please use `wrapCurrentFileDescription` to set up current context. That must be temporary solution until structural printers are ready");
+    if (layout.resolve(currentGenerationDescription) === layout.resolve(over))
+        return true;
+    return false;
+}
 //# sourceMappingURL=LayoutManager.js.map

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

@@ -11,6 +11,14 @@ export declare class MaterializedField {
     isNullableOriginalTypeField?: boolean | undefined;
     extraMethodName: string | undefined;
     constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
+    get state(): {
+        isAccessor: true;
+        hasGetter: boolean;
+        hasSetter: boolean;
+    } | {
+        isAccessor: false;
+        isReadonly: boolean;
+    };
 }
 export declare class MaterializedMethod extends PeerMethod {
     decl: idl.IDLConstructor | idl.IDLMethod | undefined;

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../idl';
-import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
+import { copyMethod, FieldModifier, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
 import { qualifiedName } from './idl/common';
 import { PeerMethod, PeerMethodSignature } from './PeerMethod';
@@ -24,6 +24,31 @@ export class MaterializedField {
         this.outArgConvertor = outArgConvertor;
         this.isNullableOriginalTypeField = isNullableOriginalTypeField;
         this.extraMethodName = extraMethodName;
+        const isReadonly = field.modifiers.includes(FieldModifier.READONLY);
+        const isGetter = field.modifiers.includes(FieldModifier.GET);
+        const isSetter = field.modifiers.includes(FieldModifier.SET);
+        if (isReadonly && (isGetter || isSetter))
+            throw new Error(`Unsupported modifiers combination: field can be either readonly or getter/setter or mutable for field ${field.name}`);
+        if (isSetter && !isGetter)
+            throw new Error(`Unsupported modifiers combination: if setter is defined getter must be defined too for field ${field.name}`);
+    }
+    get state() {
+        const hasGetter = this.field.modifiers.includes(FieldModifier.GET);
+        const hasSetter = this.field.modifiers.includes(FieldModifier.SET);
+        if (hasGetter || hasSetter) {
+            return {
+                isAccessor: true,
+                hasGetter,
+                hasSetter
+            };
+        }
+        else {
+            const isReadonly = this.field.modifiers.includes(FieldModifier.READONLY);
+            return {
+                isAccessor: false,
+                isReadonly
+            };
+        }
     }
 }
 export class MaterializedMethod extends PeerMethod {

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

@@ -4,11 +4,11 @@ import { LanguageWriter } from '../LanguageWriters/LanguageWriter';
 import { IdlNameConvertor } from '../LanguageWriters';
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from '../LibraryInterface';
-import { BuilderClass } from './BuilderClass';
 import { MaterializedClass } from './Materialized';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
 import { NativeModuleType } from '../LanguageWriters/common';
+import { ReferenceResolver } from './ReferenceResolver';
 export interface GlobalScopeDeclarations {
     methods: idl.IDLMethod[];
     constants: idl.IDLConstant[];
@@ -10259,13 +10259,11 @@ export declare class PeerLibrary implements LibraryInterface {
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
     layout: LayoutManager;
-    private _syntheticFile;
-    initSyntheticEntries(file: idl.IDLFile): void;
-    getSyntheticData(): idl.IDLInterface[];
-    readonly files: idl.IDLFile[];
+    private _files;
+    get files(): idl.IDLFile[];
+    set files(value: idl.IDLFile[]);
     readonly auxFiles: idl.IDLFile[];
-    readonly builderClasses: Map<string, BuilderClass>;
-    get buildersToGenerate(): BuilderClass[];
+    private resolver;
     readonly materializedClasses: Map<string, MaterializedClass>;
     get orderedMaterialized(): MaterializedClass[];
     constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean);
@@ -10273,8 +10271,6 @@ export declare class PeerLibrary implements LibraryInterface {
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
     createTypeNameConvertor(language: Language): IdlNameConvertor;
-    protected readonly targetNameConvertorInstance: IdlNameConvertor;
-    private readonly interopNameConvertorInstance;
     get libraryPrefix(): string;
     createContinuationParameters(continuationType: idl.IDLType): idl.IDLParameter[];
     createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
@@ -10283,18 +10279,13 @@ export declare class PeerLibrary implements LibraryInterface {
     setCurrentContext(context: string | undefined): void;
     findFileByOriginalFilename(filename: string): idl.IDLFile | undefined;
     mapType(type: idl.IDLType): string;
-    private referenceCache;
-    enableCache(): void;
-    resolveTypeReference(type: idl.IDLReferenceType, singleStep?: boolean): idl.IDLEntry | undefined;
-    private resolveTypeReferenceUncached;
-    private _useFallback;
-    disableFallback(): void;
-    resolveNamedNode(target: string[], pov?: idl.IDLNode | undefined): idl.IDLEntry | undefined;
-    resolveImport(target: idl.IDLImport): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, options?: {
+        terminalImports?: boolean;
+        unresolvedOk?: boolean;
+    }): 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;
-    getInteropName(node: idl.IDLNode): string;
     toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
     setFileLayout(strategy: LayoutManagerStrategy): void;
     withFileLayout(strategy: LayoutManagerStrategy, op: () => void): void;
@@ -10305,4 +10296,5 @@ export declare const ArkFunction: idl.IDLPrimitiveType;
 export declare const ArkDate: idl.IDLPrimitiveType;
 export declare const ArkCustomObject: idl.IDLPrimitiveType;
 export declare function cleanPrefix(name: string, prefix: string): string;
+export declare function forceTypedefAsResource(resolver: ReferenceResolver, type: idl.IDLType, decl: idl.IDLTypedef): boolean;
 //# sourceMappingURL=PeerLibrary.d.ts.map