@idlizer/core 2.0.26 → 2.0.28

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

@@ -12,167 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { generatorConfiguration } from '../../config';
 import * as idl from '../../idl';
-import { qualifiedName } from '../../peer-generation/idl/common';
+import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
-import { capitalize } from '../../util';
-import { maybeTransformManagedCallback } from '../ArgConvertors';
-import { convertNode, convertType } from '../nameConvertor';
-export class InteropConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-    }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
-    }
-    convertNode(node) {
-        return convertNode(this, node);
-    }
-    convertNamespace(node) {
-        throw new Error("Internal error: namespaces are not allowed on the interop layer");
-    }
-    convertInterface(node) {
-        switch (node.subkind) {
-            case idl.IDLInterfaceSubkind.AnonymousInterface:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
-            case idl.IDLInterfaceSubkind.Interface:
-            case idl.IDLInterfaceSubkind.Class:
-                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
-                    return this.make(node.name, true);
-                }
-                return this.make(node.name);
-            case idl.IDLInterfaceSubkind.Tuple:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
-        }
-    }
-    convertEnum(node) {
-        return this.make(this.enumName(node));
-    }
-    convertTypedef(node) {
-        return this.make(node.name);
-    }
-    convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + node.name, true);
-    }
-    convertMethod(node) {
-        return this.make(node.name);
-    }
-    convertConstant(node) {
-        return this.make(node.name);
-    }
-    /////////////////////////////////////////////////////////////////////////////////////////
-    convertOptional(type) {
-        return this.convertNode(type.type);
-    }
-    convertUnion(type) {
-        return this.make(type.name, false);
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
-        }
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, true);
-            }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    convertImport(type, _) {
-        return this.make(idl.IDLCustomObjectType.name);
-    }
-    convertTypeReference(type) {
-        var _a;
-        const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                return this.make('CustomObject');
-        }
-        if (generatorConfiguration().param("parameterized").includes(refName)) {
-            return this.make('CustomObject');
-        }
-        let decl = this.resolver.toDeclaration(type);
-        if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
-        }
-        if (idl.isType(decl)) {
-            if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
-            }
-            return this.convertNode(decl);
-        }
-        let res = this.convertNode(decl);
-        if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
-        return res;
-    }
-    convertTypeParameter(type) {
-        return this.make('CustomObject');
-    }
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLVoidType: return this.make('void', true);
-            case idl.IDLI8Type: return this.make(`Int8`);
-            case idl.IDLU8Type: return this.make(`UInt8`);
-            case idl.IDLI16Type: return this.make(`Int16`);
-            case idl.IDLU16Type: return this.make(`UInt16`);
-            case idl.IDLI32Type: return this.make(`Int32`);
-            case idl.IDLU32Type: return this.make(`UInt32`);
-            case idl.IDLI64Type: return this.make(`Int64`);
-            case idl.IDLU64Type: return this.make(`UInt64`);
-            case idl.IDLF32Type: return this.make(`Float32`);
-            case idl.IDLF64Type: return this.make(`Float64`);
-            case idl.IDLNumberType: return this.make(`Number`);
-            case idl.IDLStringType: return this.make(`String`);
-            case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
-            case idl.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
-            case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLLengthType: return this.make(`Length`);
-            case idl.IDLFunctionType: return this.make(`Function`);
-            case idl.IDLDate: return this.make(`Date`);
-            case idl.IDLBufferType: return this.make('Buffer');
-            case idl.IDLPointerType: return this.make('Pointer');
-        }
-        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    enumName(target) {
-        return qualifiedName(target, "_");
-    }
-    computeTargetTypeLiteralName(decl) {
-        const map = new Map();
-        for (const prop of decl.properties) {
-            const type = this.convertNode(prop.type);
-            const values = map.has(type.text) ? map.get(type.text) : [];
-            values.push(prop.name);
-            map.set(type.text, values);
-        }
-        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
-        return `Literal_${names.join('_')}`;
-    }
-}
-export class InteropNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.interopConvertor = new InteropConvertor(resolver);
-    }
-    convert(node) {
-        return this.interopConvertor.convertNode(node).text;
-    }
-}
+import { convertType } from '../nameConvertor';
+const KInteropReturnBuffer = 'KInteropReturnBuffer';
 export class InteropReturnTypeConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -180,22 +24,24 @@ export class InteropReturnTypeConvertor {
     isVoid(method) {
         return this.convert(method.returnType) === idl.IDLVoidType.name;
     }
+    isReturnInteropBuffer(type) {
+        return this.convert(type) === KInteropReturnBuffer;
+    }
     convert(type) {
         return convertType(this, type);
     }
     convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type) || idl.IDLContainerUtils.isPromise(type)) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
             // TODO return array by some way
             return "void";
         }
-        else
-            return PrimitiveTypesInstance.NativePointer.getText();
+        return "void";
     }
     convertImport(type, importClause) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
     convertOptional(type) {
-        return this.convert(type.type);
+        return 'void';
     }
     convertPrimitiveType(type) {
         switch (type) {
@@ -215,10 +61,10 @@ export class InteropReturnTypeConvertor {
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
             case idl.IDLBufferType:
-            case idl.IDLStringType:
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
+            case idl.IDLStringType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }
@@ -230,14 +76,23 @@ export class InteropReturnTypeConvertor {
     convertTypeReference(type) {
         if (type.name.endsWith("Attribute"))
             return idl.IDLVoidType.name;
-        // Callbacks and array types return by value
-        if (this.resolver && idl.isCallback(this.resolver.toDeclaration(type))) {
-            return type.name;
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            // Callbacks and array types return by value
+            if (idl.isCallback(this.resolver.toDeclaration(type))) {
+                return type.name;
+            }
+            if (idl.isInterface(decl)) {
+                if (isMaterialized(decl, this.resolver)) {
+                    return PrimitiveTypesInstance.NativePointer.getText();
+                }
+                return KInteropReturnBuffer;
+            }
         }
-        return PrimitiveTypesInstance.NativePointer.getText();
+        return "void";
     }
     convertUnion(type) {
-        return PrimitiveTypesInstance.NativePointer.getText();
+        return KInteropReturnBuffer;
     }
 }
 export class InteropArgConvertor {

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

@@ -126,6 +126,7 @@ export class JavaTypeNameConvertor {
             case idl.IDLVoidType: return 'void';
             case idl.IDLDate: return 'Date';
             case idl.IDLBufferType: return 'byte[]';
+            case idl.IDLInteropReturnBufferType: return 'byte[]';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -146,6 +146,8 @@ export class TSTypeNameConvertor {
                 return 'Date';
             case idl.IDLBufferType:
                 return `ArrayBuffer`;
+            case idl.IDLInteropReturnBufferType:
+                return `KInteropReturnBuffer`;
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -3,7 +3,7 @@ import { Language } from "../Language";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
-import { CppInteropArgConvertor, CppInteropConvertor } from "./convertors/CppConvertors";
+import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSTypeNameConvertor } from "./convertors/ETSConvertors";
 import { InteropArgConvertor } from "./convertors/InteropConvertors";
 import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
@@ -19,9 +19,9 @@ export function createLanguageWriter(language, resolver) {
     const printer = new IndentedPrinter();
     switch (language) {
         case Language.TS: return new TSLanguageWriter(printer, resolver, new TSTypeNameConvertor(resolver));
-        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppInteropConvertor(resolver));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppConvertor(resolver));
         case Language.JAVA: return new JavaLanguageWriter(printer, resolver, new JavaTypeNameConvertor(resolver));
-        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppInteropConvertor(resolver), PrimitiveTypesInstance);
+        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppConvertor(resolver), PrimitiveTypesInstance);
         case Language.CJ: return new CJLanguageWriter(printer, resolver, new CJTypeNameConvertor(resolver), new CJIDLTypeToForeignStringConvertor(resolver));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }

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

@@ -29,7 +29,8 @@ export declare class CJMatchExpression implements LanguageExpression {
     matchValue: LanguageExpression;
     matchCases: LanguageExpression[];
     caseBlocks: LanguageExpression[];
-    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[]);
+    indentDepth?: number | undefined;
+    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[], indentDepth?: number | undefined);
     asString(): string;
 }
 export declare class CJTernaryExpression implements LanguageExpression {
@@ -139,6 +140,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     escapeKeyword(word: string): string;
+    pushNamespace(namespace: string, ident?: boolean): void;
+    popNamespace(ident?: boolean): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;

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

@@ -18,7 +18,7 @@ import { CJKeywords } from "../../languageSpecificKeywords";
 import { RuntimeType } from "../common";
 import { AssignStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { Language } from "../../Language";
-import { isDefined } from "../../util";
+import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -64,19 +64,21 @@ export class CJUnionCastExpression {
     }
 }
 export class CJMatchExpression {
-    constructor(matchValue, matchCases, caseBlocks) {
+    constructor(matchValue, matchCases, caseBlocks, indentDepth) {
         this.matchValue = matchValue;
         this.matchCases = matchCases;
         this.caseBlocks = caseBlocks;
+        this.indentDepth = indentDepth;
     }
     asString() {
+        var _a, _b, _c;
         let output = [];
         output.push(`match (${this.matchValue.asString()}) {`);
         for (let index in this.matchCases) {
-            output.push(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()} `);
+            output.push(indentedBy(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()}`, ((_a = this.indentDepth) !== null && _a !== void 0 ? _a : 0) + 1));
         }
-        output.push(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`);
-        output.push(`}`);
+        output.push(indentedBy(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`, ((_b = this.indentDepth) !== null && _b !== void 0 ? _b : 1) + 1));
+        output.push(indentedBy(`}`, ((_c = this.indentDepth) !== null && _c !== void 0 ? _c : 1)));
         return output.join('\n');
     }
 }
@@ -308,7 +310,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.printer.print('}');
     }
     generateFunctionDeclaration(name, signature) {
-        const args = signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`);
+        const args = signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`);
         return `public func ${name}(${args.join(", ")}): ${this.getNodeName(signature.returnType)}`;
     }
     writeMethodCall(receiver, method, params, nullable = false) {
@@ -388,7 +390,7 @@ export class CJLanguageWriter extends LanguageWriter {
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
         prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
@@ -482,7 +484,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString("Option.None");
     }
     makeUnwrapOptional(expression) {
-        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')]);
+        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')], this.indentDepth());
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}`);
@@ -498,7 +500,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
     }
     makeNull(value) {
-        return new StringExpression(`None<${value}>`);
+        return new StringExpression(`Option.None`);
     }
     getTagType() {
         return idl.createReferenceType("Tags");
@@ -545,6 +547,8 @@ export class CJLanguageWriter extends LanguageWriter {
     escapeKeyword(word) {
         return CJKeywords.has(word) ? word + "_" : word;
     }
+    pushNamespace(namespace, ident = true) { }
+    popNamespace(ident = true) { }
     castToInt(value, bitness) {
         return `Int${bitness}(${value})`;
     }

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

@@ -109,7 +109,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
     makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }

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

@@ -455,12 +455,16 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return this.getNodeName(type);
     }
-    makeSerializerConstructorSignature() {
-        return new NamedMethodSignature(IDLVoidType, [
+    makeSerializerConstructorSignatures() {
+        const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
             IDLUint8ArrayType,
             IDLU32Type,
-            createReferenceType("CallbackResourceHolder" /* ast */)
+            createReferenceType("CallbackResourceHolder")
         ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);
+        const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
+            createReferenceType("CallbackResourceHolder")
+        ], ["resourceHolder"], [`nullptr`], [undefined, PrintHint.AsPointer]);
+        return [ownedDataCtor, fromBufferCtor];
     }
     makeLengthSerializer(serializer, value) {
         return undefined;

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

@@ -88,6 +88,6 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
     makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
 }
 //# sourceMappingURL=TsLanguageWriter.d.ts.map

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

@@ -390,8 +390,8 @@ export class TSLanguageWriter extends LanguageWriter {
             this.makeNaryOp("<=", [ordinal, this.makeString(high.toString())])
         ]);
     }
-    makeSerializerConstructorSignature() {
-        return new NamedMethodSignature(idl.IDLVoidType, [], []);
+    makeSerializerConstructorSignatures() {
+        return [new NamedMethodSignature(idl.IDLVoidType, [], [])];
     }
 }
 //# sourceMappingURL=TsLanguageWriter.js.map

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

@@ -9,6 +9,7 @@ export interface LibraryFileInterface {
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
     get files(): LibraryFileInterface[];
+    get libraryPackages(): string[] | undefined;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;

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

@@ -1,19 +1,16 @@
-export interface GeneratorConfiguration {
-    param<T>(name: string): T;
-    readonly params: Record<string, any>;
-    TypePrefix: string;
-    LibraryPrefix: string;
-    OptionalPrefix: string;
+export interface CoreConfiguration {
+    readonly TypePrefix: string;
+    readonly LibraryPrefix: string;
+    readonly OptionalPrefix: string;
+    readonly rootComponents: string[];
+    readonly standaloneComponents: string[];
+    readonly parameterized: string[];
+    readonly ignoreMaterialized: string[];
+    readonly builderClasses: string[];
+    readonly forceMaterialized: string[];
 }
-export declare class BaseGeneratorConfiguration implements GeneratorConfiguration {
-    readonly params: Record<string, any>;
-    constructor(params?: Record<string, any>);
-    param<T>(name: string): T;
-    get TypePrefix(): string;
-    get LibraryPrefix(): string;
-    get OptionalPrefix(): string;
-}
-export declare function setDefaultConfiguration(config: GeneratorConfiguration): void;
-export declare function generatorConfiguration(): GeneratorConfiguration;
+export declare const defaultCoreConfuguration: CoreConfiguration;
+export declare function setDefaultConfiguration<T extends CoreConfiguration>(config: T): void;
+export declare function generatorConfiguration<T extends CoreConfiguration>(): T;
 export declare function generatorTypePrefix(): string;
 //# sourceMappingURL=config.d.ts.map

package/build/lib/src/config.js

@@ -12,22 +12,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export class BaseGeneratorConfiguration {
-    constructor(params = {}) {
-        this.params = {};
-        Object.assign(this.params, Object.assign({ TypePrefix: "", LibraryPrefix: "", OptionalPrefix: "" }, params));
-    }
-    param(name) {
-        if (name in this.params) {
-            return this.params[name];
-        }
-        throw new Error(`${name} is unknown`);
-    }
-    get TypePrefix() { return this.param("TypePrefix"); }
-    get LibraryPrefix() { return this.param("LibraryPrefix"); }
-    get OptionalPrefix() { return this.param("OptionalPrefix"); }
-}
-let currentConfig = new BaseGeneratorConfiguration();
+export const defaultCoreConfuguration = {
+    TypePrefix: "",
+    LibraryPrefix: "",
+    OptionalPrefix: "",
+    rootComponents: [],
+    standaloneComponents: [],
+    parameterized: [],
+    ignoreMaterialized: [],
+    builderClasses: [],
+    forceMaterialized: [],
+};
+let currentConfig = defaultCoreConfuguration;
 export function setDefaultConfiguration(config) {
     currentConfig = config;
 }
@@ -36,6 +32,6 @@ export function generatorConfiguration() {
 }
 export function generatorTypePrefix() {
     const conf = generatorConfiguration();
-    return `${conf.param("TypePrefix")}${conf.param("LibraryPrefix")}`;
+    return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
 //# sourceMappingURL=config.js.map

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

@@ -86,7 +86,6 @@ export interface IDLNamedNode extends IDLNode {
 export interface IDLEntry extends IDLNode, IDLNamedNode {
     _idlEntryBrand: any;
     comment?: string;
-    scope?: IDLEntry[];
     namespace?: IDLNamespace;
 }
 export interface IDLType extends IDLNode {
@@ -288,6 +287,7 @@ export declare const IDLUint8ArrayType: IDLContainerType;
 export declare const IDLFunctionType: IDLPrimitiveType;
 export declare const IDLLengthType: IDLPrimitiveType;
 export declare const IDLCustomObjectType: IDLPrimitiveType;
+export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
 export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;

package/build/lib/src/idl.js

@@ -98,7 +98,7 @@ export var IDLInterfaceSubkind;
     IDLInterfaceSubkind[IDLInterfaceSubkind["Tuple"] = 3] = "Tuple";
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 export function forEachChild(node, cbEnter, cbLeave) {
-    var _a, _b, _c;
+    var _a, _b;
     cbEnter(node);
     switch (node.kind) {
         case IDLKind.Namespace:
@@ -111,7 +111,6 @@ export function forEachChild(node, cbEnter, cbLeave) {
             concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            (_a = concrete.scope) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.Method:
@@ -119,14 +118,14 @@ export function forEachChild(node, cbEnter, cbLeave) {
         case IDLKind.Callback:
         case IDLKind.Constructor: {
             let concrete = node;
-            (_b = concrete.parameters) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             if (concrete.returnType)
                 forEachChild(concrete.returnType, cbEnter, cbLeave);
             break;
         }
         case IDLKind.UnionType: {
             let concrete = node;
-            (_c = concrete.types) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.OptionalType: {
@@ -334,6 +333,7 @@ export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
 export const IDLFunctionType = createPrimitiveType('Function');
 export const IDLLengthType = createPrimitiveType('Length');
 export const IDLCustomObjectType = createPrimitiveType('CustomObject');
+export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
 export function createNamespace(name, extendedAttributes, fileName) {
     return {
         kind: IDLKind.Namespace,
@@ -746,14 +746,6 @@ export function printScoped(idl) {
     throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
 }
 export function printInterface(idl) {
-    idl.methods
-        .map(it => {
-        let result = it.scope;
-        it.scope = undefined;
-        return result;
-    })
-        .filter(isDefined)
-        .forEach(scope => idl.scope ? idl.scope.push(...scope) : idl.scope = scope);
     return [
         ...printExtendedAttributes(idl, 0),
         `interface ${idl.name}${hasSuperType(idl) ? ": " + printType(idl.inheritance[0]) : ""} {`,
@@ -852,7 +844,6 @@ export function toIDLString(entries, options) {
     let indent = 0;
     const generatedIdl = entries
         .map(it => printIDL(it, options))
-        .concat(printScopes(entries))
         .flat()
         .filter(isDefined)
         .filter(it => it.length > 0)
@@ -872,12 +863,6 @@ export function verifyIDLString(source) {
     webidl2.validate(webidl2.parse(source));
     return true;
 }
-function printScopes(entries) {
-    return entries
-        .map((it) => it.scope)
-        .filter(isDefined)
-        .flatMap((it) => it.map(printScoped));
-}
 export function hasExtAttribute(node, attribute) {
     var _a;
     return ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find((it) => it.name == attribute)) != undefined;

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

@@ -37,6 +37,8 @@ export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
+export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/index.js

@@ -51,6 +51,8 @@ export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
+export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/inheritance.js

@@ -39,9 +39,9 @@ export function isCommonMethodOrSubclass(typeChecker, decl) {
     return isSubclass;
 }
 export function determineInheritanceRole(name) {
-    if (generatorConfiguration().param("rootComponents").includes(name))
+    if (generatorConfiguration().rootComponents.includes(name))
         return InheritanceRole.Root;
-    if (generatorConfiguration().param("standaloneComponents").includes(name))
+    if (generatorConfiguration().standaloneComponents.includes(name))
         return InheritanceRole.Standalone;
     return InheritanceRole.Heir;
 }