@idlizer/core 2.0.33 → 2.0.36

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -888,11 +888,19 @@ export class FunctionConvertor extends BaseArgConvertor {
 }
 export class MaterializedClassConvertor extends BaseArgConvertor {
     constructor(param, declaration) {
-        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, true, param);
+        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
-        throw new Error("Must never be used");
+        switch (writer.language) {
+            case Language.CPP:
+                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
+            case Language.JAVA:
+            case Language.CJ:
+                return `MaterializedBase.toPeerPtr(${param})`;
+            default:
+                return `toPeerPtr(${param})`;
+        }
     }
     convertorSerialize(param, value, printer) {
         printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${this.declaration.name}`, [
@@ -907,7 +915,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         return idl.createReferenceType(this.declaration);
     }
     interopType() {
-        throw new Error("Must never be used");
+        return idl.IDLPointerType;
     }
     isPointerType() {
         return false;

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -216,7 +216,7 @@ export declare abstract class LanguageWriter {
     resolver: ReferenceResolver;
     language: Language;
     protected namespaceStack: string[];
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again (or better rework LWs)
     language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
@@ -235,6 +235,8 @@ export declare abstract class LanguageWriter {
     abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -392,7 +392,7 @@ export class NamedMethodSignature extends MethodSignature {
 //                    LANGUAGE WRITER                         //
 ////////////////////////////////////////////////////////////////
 export class LanguageWriter {
-    constructor(printer, resolver, // TODO make protected again
+    constructor(printer, resolver, // TODO make protected again (or better rework LWs)
     language) {
         this.printer = printer;
         this.resolver = resolver;

package/build/lib/src/LanguageWriters/convertors/CJConvertors.js

@@ -106,7 +106,8 @@ export class CJTypeNameConvertor {
             case idl.IDLF64Type: return 'Float64';
             case idl.IDLPointerType: return 'UInt64';
             case idl.IDLVoidType: return 'Unit';
-            case idl.IDLBufferType: return 'Array<UInt8>';
+            case idl.IDLBufferType:
+            case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -239,8 +239,6 @@ export class CppReturnTypeConvertor {
     convertPrimitiveType(type) {
         if (type == idl.IDLUndefinedType)
             return 'void';
-        if (type == idl.IDLNumberType)
-            return generatorConfiguration().TypePrefix + 'Int32'; // :(
         return this.convertor.convert(type);
     }
     convertTypeParameter(type) {

package/build/lib/src/LanguageWriters/convertors/ETSConvertors.js

@@ -77,6 +77,7 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
             case idl.IDLBufferType: return 'NativeBuffer';
+            case idl.IDLBigintType: return 'long';
         }
         return super.convertPrimitiveType(type);
     }

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.js

@@ -35,13 +35,13 @@ export class InteropReturnTypeConvertor {
             // TODO return array by some way
             return "void";
         }
-        return "void";
+        return KInteropReturnBuffer;
     }
     convertImport(type, importClause) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
     convertOptional(type) {
-        return 'void';
+        return KInteropReturnBuffer;
     }
     convertPrimitiveType(type) {
         switch (type) {
@@ -55,8 +55,8 @@ export class InteropReturnTypeConvertor {
             case idl.IDLU64Type:
             case idl.IDLF16Type:
             case idl.IDLF32Type:
-            case idl.IDLF64Type:
-            case idl.IDLNumberType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLF64Type: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLNumberType: return PrimitiveTypesInstance.Number.getText();
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
@@ -64,8 +64,8 @@ export class InteropReturnTypeConvertor {
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
-            case idl.IDLStringType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);
@@ -110,10 +110,12 @@ export class InteropArgConvertor {
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLI64Type: return "KLong";
+            case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
-            case idl.IDLNumberType: return 'number';
-            case idl.IDLBigintType: return 'bigint';
+            case idl.IDLNumberType: return 'number'; // should be removed! It is KInteropNumber or smth
+            case idl.IDLBigintType: return 'bigint'; // should be removed! It is KLong or smth
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
@@ -122,7 +124,7 @@ export class InteropArgConvertor {
             case idl.IDLDate: return 'KLong';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType: return PrimitiveTypesInstance.NativePointer.getText();
-            case idl.IDLPointerType: return "KPointer"; //PrimitiveType.NativePointer.getText()
+            case idl.IDLPointerType: return 'KPointer'; // return PrimitiveTypesInstance.NativePointer.getText()
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);
     }

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.d.ts

@@ -90,6 +90,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.js

@@ -373,6 +373,13 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.print(`}`);
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`writeTypeDeclaration not implemented`);
+    }
+    writeConstant(constName, constType, constVal) {
+        const namespacePrefix = this.namespaceStack.join('_');
+        this.print(`const ${namespacePrefix}${constName}: ${this.getNodeName(constType)} = ${constVal !== null && constVal !== void 0 ? constVal : ''}`);
+    }
     writeMethodImplementation(method, op) {
         this.writeDeclaration(method.name, method.signature, method.modifiers, " {");
         this.pushIndent();

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.d.ts

@@ -1,4 +1,4 @@
-import { IDLContainerType, IDLEnum, IDLNode, IDLType } from '../../idl';
+import { IDLContainerType, IDLEnum, IDLNode, IDLType, IDLTypedef } from '../../idl';
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
@@ -46,6 +46,8 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
+    writeTypeDeclaration(decl: IDLTypedef): void;
+    writeConstant(constName: string, constType: IDLType, constVal?: string): void;
     /**
      * Writes multiline comments decorated with stars
      */

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.js

@@ -220,6 +220,12 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writeProperty(propName, propType, mutable = true) {
         throw new Error("writeProperty for c++ is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`writeTypeDeclaration not implemented`);
+    }
+    writeConstant(constName, constType, constVal) {
+        this.print(`${this.getNodeName(constType)} ${constName}${constVal ? ' = ' + constVal : ''};`);
+    }
     /**
      * Writes multiline comments decorated with stars
      */

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -54,7 +54,13 @@ class ArkTSMapForEachStatement {
         this.op = op;
     }
     write(writer) {
-        writer.print(`// TODO: map serialization not implemented`);
+        writer.print(`for (const pair of ${this.map}) {`);
+        writer.pushIndent();
+        writer.print(`const ${this.key} = pair[0]`);
+        writer.print(`const ${this.value} = pair[1]`);
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
     }
 }
 export class ArkTSEnumEntityStatement {

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -41,6 +41,8 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js

@@ -152,6 +152,12 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     writeProperty(propName, propType) {
         throw new Error("writeProperty for Java is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`Type declarations do not exist in Java, use something else`);
+    }
+    writeConstant(constName, constType, constVal) {
+        throw new Error("writeConstant for Java is not implemented yet.");
+    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
     }

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts

@@ -54,6 +54,8 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
     makeNull(): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -234,16 +234,25 @@ export class TSLanguageWriter extends LanguageWriter {
     writeProperty(propName, propType) {
         throw new Error("writeProperty for TS is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        var _a;
+        const type = this.getNodeName(decl.type);
+        const typeParams = ((_a = decl.typeParameters) === null || _a === void 0 ? void 0 : _a.length) ? `<${decl.typeParameters.join(",").replace("[]", "")}>` : "";
+        this.print(`export type ${decl.name}${typeParams} = ${type};`);
+    }
+    writeConstant(constName, constType, constVal) {
+        this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
+    }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
             .map(it => this.mapMethodModifier(it)).join(" ");
         if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER)) {
-            prefix = `get ${prefix}`;
+            prefix = `${prefix} get`;
         }
         else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) {
-            prefix = `set ${prefix}`;
+            prefix = `${prefix} set`;
             needReturn = false;
         }
         else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.FREE)) {

package/build/lib/src/from-idl/DtsPrinter.d.ts

@@ -1,5 +1,5 @@
 import { stringOrNone } from "../util";
-import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLImport, IDLPackage, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
+import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLFile, IDLImport, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
 import { Language } from "../Language";
 export declare class CustomPrintVisitor {
     private resolver;
@@ -19,7 +19,7 @@ export declare class CustomPrintVisitor {
     printVersion(node: IDLVersion): void;
     printNamespace(node: IDLNamespace): void;
     printImport(node: IDLImport): void;
-    printPackage(node: IDLPackage): void;
+    printPackage(node: IDLFile): void;
     checkVerbatim(node: IDLEntry): void;
     private indent;
     indented(input: string): string;

package/build/lib/src/from-idl/DtsPrinter.js

@@ -13,9 +13,8 @@
  * limitations under the License.
  */
 import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isPackage, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType } from "../idl";
-import * as webidl2 from "webidl2";
-import { resolveSyntheticType, toIDLNode } from "./deserialize";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType } from "../idl";
+import { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
 export class CustomPrintVisitor {
@@ -40,9 +39,6 @@ export class CustomPrintVisitor {
         else if (isMethod(node) || isConstructor(node) || isCallable(node)) {
             this.printMethod(node);
         }
-        else if (isPackage(node)) {
-            this.printPackage(node);
-        }
         else if (isImport(node)) {
             this.printImport(node);
         }
@@ -103,12 +99,6 @@ export class CustomPrintVisitor {
             this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
         }
         else {
-            // restore globalScope
-            if (hasExtAttribute(node, IDLExtendedAttributes.GlobalScope)) {
-                node.methods.map(it => this.printMethod(it, true));
-                node.constants.map(it => this.printConstant(it));
-                return;
-            }
             let interfaces = node.inheritance;
             let keyword = "extends";
             if (node.subkind === IDLInterfaceSubkind.Class) {
@@ -124,8 +114,8 @@ export class CustomPrintVisitor {
             this.currentInterface = node;
             this.pushIndent();
             node.constructors.map(it => this.visit(it));
-            node.properties.map(it => this.visit(it));
-            node.methods.map(it => this.visit(it));
+            node.properties.filter(it => !it.isStatic).map(it => this.visit(it));
+            node.methods.filter(it => !it.isStatic).map(it => this.visit(it));
             node.callables.map(it => this.visit(it));
             let verbatim = getVerbatimDts(node);
             if (verbatim) {
@@ -244,7 +234,7 @@ export class CustomPrintVisitor {
         this.print(`// import ${node.clause.join(".")}${node.name ? " as " : ""}${node.name || ""}`);
     }
     printPackage(node) {
-        this.print(`// package ${node.clause.join(".")}`);
+        this.print(`// package ${node.packageClause.join(".")}`);
     }
     checkVerbatim(node) {
         let verbatim = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
@@ -353,10 +343,9 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    webidl2.parse(content)
-        .filter(it => !!it.type)
-        .map(it => toIDLNode(name, it))
-        .forEach(it => {
+    const idlFile = toIDLFile(name, content);
+    printer.printPackage(idlFile);
+    idlFile.entries.forEach(it => {
         transformMethodsAsync2ReturnPromise(it);
         printer.visit(it);
     });

package/build/lib/src/from-idl/common.d.ts

@@ -1,5 +1,5 @@
-import { IDLEntry } from "../idl";
+import { IDLFile } from "../idl";
 export declare function fromIDL(inputDirs: string | string[], inputFiles: string | string[] | undefined, outputDir: string, extension: string, verbose: boolean, transform: (name: string, content: string) => string): void;
-export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLEntry[][];
+export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLFile[];
 export declare const licence = "/*\n * Copyright (c) 2024 Huawei Device Co., Ltd.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n";
 //# sourceMappingURL=common.d.ts.map

package/build/lib/src/from-idl/common.js

@@ -14,8 +14,7 @@
  */
 import * as fs from "fs";
 import * as path from "path";
-import * as webidl2 from "webidl2";
-import { toIDLNode } from "./deserialize";
+import { toIDLFile } from "./deserialize";
 import { zip } from "../util";
 function getFilesRecursive(dirPath, arrayOfFiles = []) {
     let files = fs.readdirSync(dirPath);
@@ -66,12 +65,7 @@ export function scanIDL(inputDir, inputFile) {
         ? [path.join(inputDir, inputFile)]
         : fs.readdirSync(inputDir)
             .map((elem) => path.join(inputDir, elem));
-    return files
-        .map((file) => {
-        let content = fs.readFileSync(file).toString();
-        let parsed = webidl2.parse(content);
-        return parsed.filter(it => !!it.type).map(it => toIDLNode(file, it));
-    });
+    return files.map(it => toIDLFile(it));
 }
 export const licence = `/*
  * Copyright (c) 2024 Huawei Device Co., Ltd.

package/build/lib/src/from-idl/deserialize.d.ts

@@ -1,8 +1,5 @@
-import * as webidl2 from "webidl2";
 import * as idl from "../idl";
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-export declare function toIDLNode(file: string, node: webidl2.IDLRootType): idl.IDLEntry;
-export declare function toIDL(file: string): idl.IDLEntry[];
-export declare function toIDLFile(fileName: string): idl.IDLFile;
+export declare function toIDLFile(fileName: string, content?: string): idl.IDLFile;
 //# sourceMappingURL=deserialize.d.ts.map

package/build/lib/src/from-idl/deserialize.js

@@ -28,16 +28,13 @@ export function addSyntheticType(name, type) {
 export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
-export function toIDLNode(file, node) {
+function toIDLNode(file, node) {
     return toIDLNodeForward(file, node);
 }
 function toIDLNodeForward(file, node) {
     if (isEnum(node)) {
         return toIDLEnum(file, node);
     }
-    if (isPackage(node)) {
-        return toIDLPackage(node);
-    }
     if (isImport(node)) {
         return toIDLImport(node);
     }
@@ -85,13 +82,6 @@ function isImport(node) {
 function isCallable(node) {
     return node.extAttrs.some(it => it.name == "Invoke");
 }
-function toIDLPackage(node) {
-    if (node.clause.startsWith('"')) { // TODO: remove after new schema formation
-        //node.clause = node.clause.substring(1, node.clause.length - 1)
-        throw new Error("Obsolete IDL-source syntax detected");
-    }
-    return idl.createPackage(node.clause.split("."));
-}
 function toIDLImport(node) {
     // console.log(node)
     return idl.createImport(node.clause.split("."), node.alias || undefined);
@@ -369,14 +359,22 @@ function findExtendedAttribute(extAttrs, name) {
     const attr = extAttrs.find(it => it.name === name);
     return attr ? toExtendedAttributeValue(attr) : undefined;
 }
-export function toIDL(file) {
-    const content = fs.readFileSync(file).toString();
-    return webidl2.parse(content).map(it => toIDLNode(file, it));
-}
-export function toIDLFile(fileName) {
-    const content = fs.readFileSync(fileName).toString();
-    const entries = webidl2.parse(content).map(it => toIDLNode(fileName, it));
-    const file = idl.createFile(entries, fileName);
+export function toIDLFile(fileName, content) {
+    if (undefined === content)
+        content = fs.readFileSync(fileName).toString();
+    let packageClause = [];
+    const entries = webidl2.parse(content)
+        .filter(it => {
+        if (!it.type)
+            return false;
+        if (isPackage(it)) {
+            packageClause = it.clause.split(".");
+            return false;
+        }
+        return true;
+    })
+        .map(it => toIDLNode(fileName, it));
+    const file = idl.createFile(entries, fileName, packageClause);
     return idl.linkParentBack(file);
 }
 //# sourceMappingURL=deserialize.js.map

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

@@ -1,33 +1,31 @@
 import { stringOrNone } from "./util";
 export declare enum IDLKind {
     Interface = 0,
-    Package = 1,
-    Import = 2,
-    Callback = 3,
-    Const = 4,
-    Property = 5,
-    Parameter = 6,
-    Method = 7,
-    Callable = 8,
-    Constructor = 9,
-    Enum = 10,
-    EnumMember = 11,
-    Typedef = 12,
-    PrimitiveType = 13,
-    ContainerType = 14,
-    UnspecifiedGenericType = 15,
-    ReferenceType = 16,
-    UnionType = 17,
-    TypeParameterType = 18,
-    OptionalType = 19,
-    Version = 20,
-    Namespace = 21,
-    File = 22
+    Import = 1,
+    Callback = 2,
+    Const = 3,
+    Property = 4,
+    Parameter = 5,
+    Method = 6,
+    Callable = 7,
+    Constructor = 8,
+    Enum = 9,
+    EnumMember = 10,
+    Typedef = 11,
+    PrimitiveType = 12,
+    ContainerType = 13,
+    UnspecifiedGenericType = 14,
+    ReferenceType = 15,
+    UnionType = 16,
+    TypeParameterType = 17,
+    OptionalType = 18,
+    Version = 19,
+    Namespace = 20,
+    File = 21
 }
 export declare enum IDLEntity {
     Class = "Class",
     Interface = "Interface",
-    Package = "Package",
     Import = "Import",
     Intersection = "Intersection",
     Literal = "Literal",
@@ -49,7 +47,6 @@ export declare enum IDLExtendedAttributes {
     DtsName = "DtsName",
     DtsTag = "DtsTag",
     Entity = "Entity",
-    GlobalScope = "GlobalScope",
     Import = "Import",
     IndexSignature = "IndexSignature",
     Interfaces = "Interfaces",
@@ -83,6 +80,7 @@ export interface IDLNode {
     documentation?: string;
 }
 export interface IDLFile extends IDLNode {
+    packageClause: string[];
     entries: IDLEntry[];
     fileName?: string;
 }
@@ -207,10 +205,6 @@ export interface IDLInterface extends IDLEntry {
     methods: IDLMethod[];
     callables: IDLCallable[];
 }
-export interface IDLPackage extends IDLEntry {
-    kind: IDLKind.Package;
-    clause: string[];
-}
 export interface IDLImport extends IDLEntry {
     kind: IDLKind.Import;
     clause: string[];
@@ -238,7 +232,6 @@ export declare function isEnumMember(type: IDLNode): type is IDLEnumMember;
 export declare function isUnionType(type: IDLNode): type is IDLUnionType;
 export declare function isTypeParameterType(type: IDLNode): type is IDLTypeParameterType;
 export declare function isInterface(node: IDLNode): node is IDLInterface;
-export declare function isPackage(type: IDLNode): type is IDLPackage;
 export declare function isImport(type: IDLNode): type is IDLImport;
 export declare function isCallable(node: IDLNode): node is IDLCallable;
 export declare function isMethod(node: IDLNode): node is IDLMethod;
@@ -317,8 +310,7 @@ export declare function createUnspecifiedGenericType(name: string, typeArguments
 export declare function entityToType(entity: IDLNode): IDLType;
 export declare function createContainerType(container: IDLContainerKind, element: IDLType[]): IDLContainerType;
 export declare function createUnionType(types: IDLType[], name?: string): IDLUnionType;
-export declare function createFile(entries: IDLEntry[], fileName?: string): IDLFile;
-export declare function createPackage(clause: string[]): IDLPackage;
+export declare function createFile(entries: IDLEntry[], fileName?: string, packageClause?: string[]): IDLFile;
 export declare function createImport(clause: string[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLImport;
 export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
 export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
@@ -361,7 +353,7 @@ export declare function printExtendedAttributes(idl: IDLNode, indentLevel: numbe
 export declare const attributesToQuote: Set<IDLExtendedAttributes>;
 export declare function printFunction(idl: IDLFunction): PrintedLine[];
 export declare function printMethod(idl: IDLMethod): PrintedLine[];
-export declare function printPackage(idl: IDLPackage): PrintedLine[];
+export declare function printPackage(idl: IDLFile): PrintedLine[];
 export declare function printImport(idl: IDLImport): PrintedLine[];
 export declare function printNamespace(idl: IDLNamespace): PrintedLine[];
 export declare function printCallback(idl: IDLCallback): PrintedLine[];
@@ -378,7 +370,7 @@ export interface IDLPrintOptions {
     disableEnumInitializers: boolean;
     allowUnknownKinds: boolean;
 }
-export declare function toIDLString(entries: IDLEntry[], options: Partial<IDLPrintOptions>): string;
+export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOptions>): string;
 export declare function verifyIDLString(source: string): true;
 export declare function hasExtAttribute(node: IDLNode, attribute: IDLExtendedAttributes): boolean;
 export declare function getExtAttribute(node: IDLNode, name: IDLExtendedAttributes): stringOrNone;