@idlizer/core 2.0.33 → 2.0.35

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

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorTypePrefix } from "../config";
+import { generatorConfiguration, generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppNameConvertor } from "./convertors/CppConvertors";
@@ -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<${generatorConfiguration().TypePrefix}${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,7 @@ 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 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,7 @@ 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;
     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,9 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.print(`}`);
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`writeTypeDeclaration not implemented`);
+    }
     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,7 @@ 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;
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -220,6 +220,9 @@ 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`);
+    }
     /**
      * 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,7 @@ 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;
     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,9 @@ 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`);
+    }
     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,7 @@ 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;
     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,22 @@ 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};`);
+    }
     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;

package/build/lib/src/idl.js

@@ -19,34 +19,32 @@ import { IDLKeywords } from "./languageSpecificKeywords";
 export var IDLKind;
 (function (IDLKind) {
     IDLKind[IDLKind["Interface"] = 0] = "Interface";
-    IDLKind[IDLKind["Package"] = 1] = "Package";
-    IDLKind[IDLKind["Import"] = 2] = "Import";
-    IDLKind[IDLKind["Callback"] = 3] = "Callback";
-    IDLKind[IDLKind["Const"] = 4] = "Const";
-    IDLKind[IDLKind["Property"] = 5] = "Property";
-    IDLKind[IDLKind["Parameter"] = 6] = "Parameter";
-    IDLKind[IDLKind["Method"] = 7] = "Method";
-    IDLKind[IDLKind["Callable"] = 8] = "Callable";
-    IDLKind[IDLKind["Constructor"] = 9] = "Constructor";
-    IDLKind[IDLKind["Enum"] = 10] = "Enum";
-    IDLKind[IDLKind["EnumMember"] = 11] = "EnumMember";
-    IDLKind[IDLKind["Typedef"] = 12] = "Typedef";
-    IDLKind[IDLKind["PrimitiveType"] = 13] = "PrimitiveType";
-    IDLKind[IDLKind["ContainerType"] = 14] = "ContainerType";
-    IDLKind[IDLKind["UnspecifiedGenericType"] = 15] = "UnspecifiedGenericType";
-    IDLKind[IDLKind["ReferenceType"] = 16] = "ReferenceType";
-    IDLKind[IDLKind["UnionType"] = 17] = "UnionType";
-    IDLKind[IDLKind["TypeParameterType"] = 18] = "TypeParameterType";
-    IDLKind[IDLKind["OptionalType"] = 19] = "OptionalType";
-    IDLKind[IDLKind["Version"] = 20] = "Version";
-    IDLKind[IDLKind["Namespace"] = 21] = "Namespace";
-    IDLKind[IDLKind["File"] = 22] = "File";
+    IDLKind[IDLKind["Import"] = 1] = "Import";
+    IDLKind[IDLKind["Callback"] = 2] = "Callback";
+    IDLKind[IDLKind["Const"] = 3] = "Const";
+    IDLKind[IDLKind["Property"] = 4] = "Property";
+    IDLKind[IDLKind["Parameter"] = 5] = "Parameter";
+    IDLKind[IDLKind["Method"] = 6] = "Method";
+    IDLKind[IDLKind["Callable"] = 7] = "Callable";
+    IDLKind[IDLKind["Constructor"] = 8] = "Constructor";
+    IDLKind[IDLKind["Enum"] = 9] = "Enum";
+    IDLKind[IDLKind["EnumMember"] = 10] = "EnumMember";
+    IDLKind[IDLKind["Typedef"] = 11] = "Typedef";
+    IDLKind[IDLKind["PrimitiveType"] = 12] = "PrimitiveType";
+    IDLKind[IDLKind["ContainerType"] = 13] = "ContainerType";
+    IDLKind[IDLKind["UnspecifiedGenericType"] = 14] = "UnspecifiedGenericType";
+    IDLKind[IDLKind["ReferenceType"] = 15] = "ReferenceType";
+    IDLKind[IDLKind["UnionType"] = 16] = "UnionType";
+    IDLKind[IDLKind["TypeParameterType"] = 17] = "TypeParameterType";
+    IDLKind[IDLKind["OptionalType"] = 18] = "OptionalType";
+    IDLKind[IDLKind["Version"] = 19] = "Version";
+    IDLKind[IDLKind["Namespace"] = 20] = "Namespace";
+    IDLKind[IDLKind["File"] = 21] = "File";
 })(IDLKind || (IDLKind = {}));
 export var IDLEntity;
 (function (IDLEntity) {
     IDLEntity["Class"] = "Class";
     IDLEntity["Interface"] = "Interface";
-    IDLEntity["Package"] = "Package";
     IDLEntity["Import"] = "Import";
     IDLEntity["Intersection"] = "Intersection";
     IDLEntity["Literal"] = "Literal";
@@ -69,7 +67,6 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsName"] = "DtsName";
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
-    IDLExtendedAttributes["GlobalScope"] = "GlobalScope";
     IDLExtendedAttributes["Import"] = "Import";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
@@ -171,7 +168,6 @@ export function forEachChild(node, cbEnter, cbLeave) {
         case IDLKind.ReferenceType:
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
-        case IDLKind.Package:
         case IDLKind.Import:
         case IDLKind.PrimitiveType:
         case IDLKind.Version:
@@ -228,9 +224,6 @@ export function isTypeParameterType(type) {
 export function isInterface(node) {
     return node.kind === IDLKind.Interface;
 }
-export function isPackage(type) {
-    return type.kind == IDLKind.Package;
-}
 export function isImport(type) {
     return type.kind == IDLKind.Import;
 }
@@ -400,13 +393,7 @@ export function isEqualByQualifedName(a, b) {
 }
 export function getPackageClause(entry) {
     let file = getFileFor(entry);
-    if (!file)
-        return [];
-    for (const child of file.entries)
-        if (isPackage(child))
-            return child.clause;
-    // console.warn("Expected to have one IDLPackage inside IDLFile. Using empty package name")
-    return [];
+    return (file === null || file === void 0 ? void 0 : file.packageClause) || [];
 }
 export function getPackageName(entry) {
     return getPackageClause(entry).join(".");
@@ -499,24 +486,15 @@ export function createUnionType(types, name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createFile(entries, fileName) {
+export function createFile(entries, fileName, packageClause = []) {
     return {
         kind: IDLKind.File,
+        packageClause,
         entries: entries,
         fileName,
         _idlNodeBrand: innerIdlSymbol,
     };
 }
-export function createPackage(clause) {
-    return {
-        kind: IDLKind.Package,
-        name: "",
-        clause,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
-}
 export function createImport(clause, name, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Import, name: name || "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
@@ -754,10 +732,10 @@ export function printMethod(idl) {
     ];
 }
 export function printPackage(idl) {
-    if (!idl.clause.length)
+    if (!idl.packageClause.length)
         return [];
     return [
-        `package ${idl.clause.join(".")};`
+        `package ${idl.packageClause.join(".")};`
     ];
 }
 export function printImport(idl) {
@@ -856,6 +834,7 @@ export function printTypedef(idl) {
         `typedef ${printType(idl.type)} ${idl.name};`
     ];
 }
+// TODO: use IndentedPrinter instead!
 export function printIDL(idl, options) {
     var _a;
     if (idl.kind == IDLKind.Interface)
@@ -866,8 +845,6 @@ export function printIDL(idl, options) {
         return printTypedef(idl);
     if (idl.kind == IDLKind.Callback)
         return printCallback(idl);
-    if (idl.kind == IDLKind.Package)
-        return printPackage(idl);
     if (idl.kind == IDLKind.Import)
         return printImport(idl);
     if (idl.kind == IDLKind.Namespace)
@@ -883,23 +860,27 @@ export function printIDL(idl, options) {
         throw new Error(`unexpected kind: ${idl.kind}`);
     }
 }
-export function toIDLString(entries, options) {
+export function toIDLString(file, options) {
     let indent = 0;
-    const generatedIdl = entries
+    const generated = printPackage(file);
+    return generated.concat(file.entries
         .map(it => printIDL(it, options))
         .flat()
         .filter(isDefined)
         .filter(it => it.length > 0)
         .map(it => {
-        if (it === printedIndentInc)
+        if (it === printedIndentInc) {
             ++indent;
-        else if (it === printedIndentDec)
+            return undefined;
+        }
+        else if (it === printedIndentDec) {
             --indent;
+            return undefined;
+        }
         else
             return indentedBy(it, indent);
     })
-        .join("\n");
-    return generatedIdl;
+        .filter(isDefined)).join("\n");
 }
 // throws validation error
 export function verifyIDLString(source) {

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

@@ -45,5 +45,5 @@ export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -59,5 +59,5 @@ export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 //# sourceMappingURL=index.js.map

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

@@ -31,7 +31,6 @@ export type QueryType<T> = LibraryQuery<IDLLibrary, T> | LensBuilder<T>;
 export declare function query<T>(lib: IDLLibrary, input: QueryType<T>): T;
 interface EntitiesParams {
     expandNamespaces?: boolean;
-    slipPackage?: boolean;
 }
 export declare const lib: {
     createLibrary: typeof createLibrary;
@@ -40,7 +39,7 @@ export declare const lib: {
     query: typeof query;
     select: {
         files(): LibraryReducer<readonly idl.IDLFile[]>;
-        nodes(params: EntitiesParams): LibraryQuery<readonly idl.IDLFile[], idl.IDLNode[]>;
+        nodes(params?: EntitiesParams): LibraryQuery<readonly idl.IDLFile[], idl.IDLNode[]>;
         entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
         interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
         hasExt<T extends idl.IDLNode>(attr: idl.IDLExtendedAttributes): LibraryQuery<T[], T[]>;

package/build/lib/src/library.js

@@ -139,12 +139,9 @@ const select = {
     nodes(params) {
         const key = 'entities' + serializeParam(params);
         function go(node) {
-            if (idl.isNamespace(node) && params.expandNamespaces) {
+            if (idl.isNamespace(node) && (params === null || params === void 0 ? void 0 : params.expandNamespaces)) {
                 return node.members.flatMap(go);
             }
-            if (idl.isPackage(node) && params.slipPackage) {
-                return [];
-            }
             return [node];
         }
         return req(key, xs => {

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

@@ -52,9 +52,11 @@ export declare class MaterializedClass implements PeerClassBase {
     getComponentName(): string;
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;
+    private _isGlobal;
+    setGlobalScope(): void;
     isGlobalScope(): boolean;
 }
-export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod;
+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 getMaterializedFileName(name: string): string;

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

@@ -111,6 +111,7 @@ export class MaterializedClass {
         this.methods = methods;
         this.needBeGenerated = needBeGenerated;
         this.taggedMethods = taggedMethods;
+        this._isGlobal = false;
         PeerMethod.markAndGroupOverloads(methods);
     }
     getComponentName() {
@@ -122,11 +123,17 @@ export class MaterializedClass {
     generatedName(isCallSignature) {
         return this.className;
     }
+    setGlobalScope() {
+        this._isGlobal = true;
+    }
     isGlobalScope() {
-        return idl.hasExtAttribute(this.decl, idl.IDLExtendedAttributes.GlobalScope);
+        return this._isGlobal;
     }
 }
 export function createDestroyPeerMethod(clazz) {
+    if (clazz.isGlobalScope()) {
+        return undefined;
+    }
     return new MaterializedMethod(clazz.className, clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.className)], ['peer'])));
 }
 export function getInternalClassName(name) {

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

@@ -7,7 +7,7 @@ export declare class PeerFile implements LibraryFileInterface {
     readonly peers: Map<string, PeerClass>;
     constructor(file: idl.IDLFile, isPredefined?: boolean);
     packageName(): string;
-    package(): idl.IDLPackage | undefined;
+    packageClause(): string[];
     get peersToGenerate(): PeerClass[];
     get entries(): idl.IDLEntry[];
     get originalFilename(): string;

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

@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as idl from '../idl';
 export class PeerFile {
     constructor(file, isPredefined = false) {
         this.file = file;
@@ -20,17 +19,10 @@ export class PeerFile {
         this.peers = new Map();
     }
     packageName() {
-        const packageTag = this.package();
-        if (packageTag === undefined) {
-            return "";
-        }
-        if (packageTag.name.startsWith('"') && packageTag.name.endsWith('"')) {
-            return packageTag.name.slice(1, packageTag.name.length - 1);
-        }
-        return packageTag.name;
+        return this.packageClause().join(".");
     }
-    package() {
-        return this.entries.find(it => idl.isPackage(it));
+    packageClause() {
+        return this.file.packageClause;
     }
     get peersToGenerate() {
         const peers = Array.from(this.peers.values());

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

@@ -9,10 +9,14 @@ import { MaterializedClass } from './Materialized';
 import { PeerFile } from './PeerFile';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
+export interface GlobalScopeDeclarations {
+    methods: idl.IDLMethod[];
+    constants: idl.IDLConstant[];
+}
 export declare const lenses: {
     globals: {
-        req: import("../library").LibraryReducer<idl.IDLInterface[]>;
-        pipe<T>(r: import("../library").LibraryQuery<idl.IDLInterface[], T>): {
+        req: import("../library").LibraryReducer<GlobalScopeDeclarations[]>;
+        pipe<T>(r: import("../library").LibraryQuery<GlobalScopeDeclarations[], T>): {
             req: import("../library").LibraryReducer<T>;
             pipe<T_1>(r: import("../library").LibraryQuery<T, T_1>): {
                 req: import("../library").LibraryReducer<T_1>;
@@ -5128,7 +5132,7 @@ export declare const lenses: {
             };
             query(): import("../library").LibraryReducer<T>;
         };
-        row<T_2047>(key: string, f: (x: idl.IDLInterface[]) => T_2047): {
+        row<T_2047>(key: string, f: (x: GlobalScopeDeclarations[]) => T_2047): {
             req: import("../library").LibraryReducer<T_2047>;
             pipe<T_2048>(r: import("../library").LibraryQuery<T_2047, T_2048>): {
                 req: import("../library").LibraryReducer<T_2048>;
@@ -10244,7 +10248,7 @@ export declare const lenses: {
             };
             query(): import("../library").LibraryReducer<T_2047>;
         };
-        query(): import("../library").LibraryReducer<idl.IDLInterface[]>;
+        query(): import("../library").LibraryReducer<GlobalScopeDeclarations[]>;
     };
 };
 export declare class PeerLibrary implements LibraryInterface {
@@ -10252,10 +10256,11 @@ export declare class PeerLibrary implements LibraryInterface {
     libraryPackages: string[] | undefined;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
-    get globalScopeInterfaces(): idl.IDLInterface[];
+    get globals(): GlobalScopeDeclarations[];
     layout: LayoutManager;
     private _syntheticFile;
     initSyntheticEntries(file: idl.IDLFile): void;
+    getSyntheticData(): idl.IDLInterface[];
     readonly files: PeerFile[];
     readonly builderClasses: Map<string, BuilderClass>;
     get buildersToGenerate(): BuilderClass[];

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

@@ -30,9 +30,33 @@ import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
 export const lenses = {
     globals: lib.lens(lib.select.files())
-        .pipe(lib.select.nodes({ expandNamespaces: true }))
-        .pipe(lib.select.interfaces())
-        .pipe(lib.select.hasExt(idl.IDLExtendedAttributes.GlobalScope))
+        .pipe(lib.select.nodes())
+        .pipe(lib.req('globals', (nodes) => {
+        const result = [];
+        const queue = [nodes];
+        while (queue.length) {
+            const line = {
+                constants: [],
+                methods: []
+            };
+            const next = queue.pop();
+            next.forEach(node => {
+                if (idl.isNamespace(node)) {
+                    queue.push(node.members);
+                }
+                if (idl.isConstant(node)) {
+                    line.constants.push(node);
+                }
+                if (idl.isMethod(node)) {
+                    line.methods.push(node);
+                }
+            });
+            if (line.constants.length || line.methods.length) {
+                result.push(line);
+            }
+        }
+        return result;
+    }))
 };
 export class PeerLibrary {
     asIDLLibrary() {
@@ -44,10 +68,13 @@ export class PeerLibrary {
         };
         return this._cachedIdlLibrary;
     }
-    get globalScopeInterfaces() { return query(this.asIDLLibrary(), lenses.globals); }
+    get globals() { return query(this.asIDLLibrary(), lenses.globals); }
     initSyntheticEntries(file) {
         this._syntheticFile = file;
     }
+    getSyntheticData() {
+        return this._syntheticFile.entries.filter(it => idl.isInterface(it));
+    }
     get buildersToGenerate() {
         return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
     }

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

@@ -3,6 +3,7 @@ export declare class PrimitiveType {
     protected isPointer: boolean;
     constructor(name: string, isPointer?: boolean);
     getText(): string;
+    getInterop(): string;
     toString(): string;
 }
 export declare class PrimitiveTypeList {
@@ -11,6 +12,7 @@ export declare class PrimitiveTypeList {
     static get ObjectTag(): string;
     readonly Int32: PrimitiveType;
     readonly Int64: PrimitiveType;
+    readonly Number: PrimitiveType;
     readonly Boolean: PrimitiveType;
     readonly Function: PrimitiveType;
     readonly Undefined: PrimitiveType;

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

@@ -21,6 +21,9 @@ export class PrimitiveType {
     getText() {
         return generatorConfiguration().TypePrefix + this.name;
     }
+    getInterop() {
+        return 'Interop' + this.name;
+    }
     toString() {
         return this.getText();
     }
@@ -29,6 +32,7 @@ export class PrimitiveTypeList {
     constructor() {
         this.Int32 = new PrimitiveType(`Int32`);
         this.Int64 = new PrimitiveType(`Int64`);
+        this.Number = new PrimitiveType(`Number`);
         this.Boolean = new PrimitiveType(`Boolean`);
         this.Function = new PrimitiveType(`Function`);
         this.Undefined = new PrimitiveType(`Undefined`);

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

@@ -1,4 +1,5 @@
 import * as idl from '../idl';
 import { ReferenceResolver } from './ReferenceResolver';
 export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
+export declare function isMaterializedType(type: idl.IDLType, resolver: ReferenceResolver): boolean;
 //# sourceMappingURL=isMaterialized.d.ts.map

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

@@ -43,4 +43,12 @@ export function isMaterialized(declaration, resolver) {
     }
     return false;
 }
+export function isMaterializedType(type, resolver) {
+    if (!idl.isReferenceType(type))
+        return false;
+    const decl = resolver.resolveTypeReference(type);
+    if (!decl)
+        return false;
+    return (idl.isInterface(decl) && isMaterialized(decl, resolver));
+}
 //# sourceMappingURL=isMaterialized.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.33",
+  "version": "2.0.35",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.5",
+    "@koalaui/interop": "1.5.6",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },