@idlizer/core 2.1.7 → 2.1.9-arktscgen-5

package/build/lib/src/config.js

@@ -39,7 +39,8 @@ export const CoreConfigurationSchema = D.object({
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
     hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
-    externalModuleTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
     globalPackages: T.stringArray()
@@ -58,7 +59,8 @@ export const defaultCoreConfiguration = {
     forceResource: [],
     forceContext: [],
     hooks: new Map(),
-    externalModuleTypes: new Map(),
+    externalTypes: new Map(),
+    externalPackages: [],
     moduleName: "",
     modules: new Map(),
     globalPackages: []

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

@@ -102,7 +102,7 @@ export declare const D: {
         string<T_3 extends string>(x: T_3): ConfigDescriberLeaf<T_3>;
         number<T_4 extends number>(x: T_4): ConfigDescriberLeaf<T_4>;
         boolean<T_5 extends boolean>(x: T_5): ConfigDescriberLeaf<T_5>;
-        null(x: null): ConfigDescriberLeaf<null>;
+        null(): ConfigDescriberLeaf<null>;
     };
     combine<A, B>(a: ConfigDescriberObjectLeaf<A>, b: ConfigDescriberObjectLeaf<B>): ConfigDescriberObjectLeaf<A & B>;
     printJSONSchema<T_6>(schema: ConfigDescriberLeaf<T_6>): string;

package/build/lib/src/configDescriber.js

@@ -347,7 +347,7 @@ export const D = {
                 };
             });
         },
-        null(x) {
+        null() {
             return new ConfigDescriberLeaf(xs => {
                 if (typeof xs === 'object' && xs === null) {
                     return ValidationBox.ok(null);

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

@@ -13,7 +13,7 @@
  * 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, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
+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, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
 import { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
@@ -103,7 +103,7 @@ export class CustomPrintVisitor {
             let interfaces = node.inheritance;
             let keyword = "extends";
             if (node.subkind === IDLInterfaceSubkind.Class) {
-                const superType = getSuperType(node);
+                const superType = node.inheritance.find(it => hasExtAttribute(it, IDLExtendedAttributes.Extends));
                 if (superType)
                     typeSpec += ` extends ${this.printTypeForTS(superType)}`;
                 interfaces = interfaces.slice(1);
@@ -129,8 +129,11 @@ export class CustomPrintVisitor {
         }
     }
     printMethod(node, forceAsFree = false) {
-        const returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
+        let returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
             ? `: ${this.printTypeForTS(node.returnType, true)}` : "";
+        if (hasExtAttribute(node, IDLExtendedAttributes.CommonMethod)) {
+            returnType = `: ${this.currentInterface.name}`;
+        }
         const name = isConstructor(node)
             ? this.currentInterface.subkind === IDLInterfaceSubkind.Class ? "constructor" : "new"
             : getName(node);
@@ -188,11 +191,11 @@ export class CustomPrintVisitor {
         this.print(`${isInNamespace(node) ? "" : "declare "}enum ${node.name} {`);
         this.pushIndent();
         node.elements.forEach(it => {
-            const initializer = (it.type === IDLStringType ? `"${it.initializer}"` : `${it.initializer}`);
-            this.print(`${getName(it)} = ${initializer},`);
+            const initializer = it.initializer ? (it.type === IDLStringType ? ` = "${it.initializer}"` : ` = ${it.initializer}`) : "";
+            this.print(`${getName(it)}${initializer},`);
             let originalName = getExtAttribute(it, IDLExtendedAttributes.OriginalEnumMemberName);
             if (originalName && originalName != getName(it)) {
-                this.print(`${originalName} = ${initializer},`);
+                this.print(`${originalName}${initializer},`);
             }
         });
         this.popIndent();
@@ -290,7 +293,7 @@ export class CustomPrintVisitor {
                 case IDLUndefinedType: return undefinedToVoid ? "void" : "undefined";
                 case IDLStringType: return "string";
                 case IDLVoidType: return "void";
-                case IDLThisType: return "T";
+                case IDLThisType: return this.currentInterface.name;
                 case IDLBigintType:
                 case IDLPointerType: return "number|bigint";
                 case IDLDate: return "Date";

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

@@ -39,7 +39,6 @@ export declare class IDLLinter {
     protected check(node: idl.IDLNode): void;
     protected checkValidAttributes(entry: idl.IDLEntry, validAttributes: string[]): void;
     protected checkEnumConsistency(entry: idl.IDLEnum): void;
-    private static builtinReferences;
     protected checkReferenceResolved(reference: idl.IDLReferenceType): void;
 }
 interface IDLLinterDiagnosticsSummary {

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

@@ -129,8 +129,6 @@ export class IDLLinter {
     }
     checkReferenceResolved(reference) {
         var _a, _b, _c, _d, _e, _f;
-        if (IDLLinter.builtinReferences.includes(reference.name))
-            return;
         if (this.context.hasTypeParameter(reference.name)) {
             return;
         }
@@ -156,10 +154,6 @@ export class IDLLinter {
         }
     }
 }
-IDLLinter.builtinReferences = [
-    idl.IDLTopType.name,
-    idl.IDLObjectType.name,
-];
 export class IDLLinterError extends Error {
     constructor(message, size) {
         super(message);

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

@@ -116,13 +116,12 @@ class IDLDeserializer {
     interfaceSubkind(node) {
         var _a, _b;
         const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
-        if (nodeIDLEntity == idl.IDLEntity.Class)
-            return idl.IDLInterfaceSubkind.Class;
-        if (nodeIDLEntity == idl.IDLEntity.Interface)
-            return idl.IDLInterfaceSubkind.Interface;
-        if (nodeIDLEntity == idl.IDLEntity.Tuple)
-            return idl.IDLInterfaceSubkind.Tuple;
-        return idl.IDLInterfaceSubkind.Interface;
+        switch (nodeIDLEntity) {
+            case idl.IDLEntity.Class: return idl.IDLInterfaceSubkind.Class;
+            case idl.IDLEntity.Literal: return idl.IDLInterfaceSubkind.AnonymousInterface;
+            case idl.IDLEntity.Tuple: return idl.IDLInterfaceSubkind.Tuple;
+            default: return idl.IDLInterfaceSubkind.Interface;
+        }
     }
     toIDLInterface(file, node) {
         const generics = this.extractGenerics(node.extAttrs);
@@ -133,29 +132,16 @@ class IDLDeserializer {
                 return [];
             }
             const implementations = [];
-            let extension = undefined;
             node.inheritance.forEach(it => {
                 var _a;
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.IDLExtendedAttributes.TypeArguments);
                 const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
-                const baseClass = attrs === null || attrs === void 0 ? void 0 : attrs.find(it => it.name === idl.IDLExtendedAttributes.Extends);
                 const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
-                if (baseClass) {
-                    extension = ref;
-                }
-                else {
-                    implementations.push(ref);
-                }
+                implementations.push(ref);
             });
-            if (subkind === idl.IDLInterfaceSubkind.Class && extension === undefined && this.inheritanceMode === 'multiple') {
-                extension = idl.IDLTopType;
-            }
-            if (extension) {
-                return [extension, ...implementations];
-            }
             return implementations;
         })(), node.members
             .filter(isConstructor)

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

@@ -56,10 +56,12 @@ export declare enum IDLExtendedAttributes {
     Protected = "Protected",
     Synthetic = "Synthetic",
     Throws = "Throws",
+    TraceKey = "TraceKey",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
-    HandWrittenImplementation = "HandWrittenImplementation"
+    HandWrittenImplementation = "HandWrittenImplementation",
+    ExtraMethod = "ExtraMethod"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -253,15 +255,6 @@ export declare function isSyntheticEntry(node: IDLNode): boolean;
 export declare function isOptionalType(type: IDLNode): type is IDLOptionalType;
 export declare function isVersion(node: IDLNode): node is IDLVersion;
 export declare function createOptionalType(element: IDLType, nodeInitializer?: IDLNodeInitializer): IDLOptionalType;
-/**
- * This placeholder is used when a class has no superclass.
- * Examples:
- *  class definition:               inheritance:
- * `C extends T`                  :  [T]
- * `C implements T`               :  [Top, T]
- * `C extends T implements I, J`  :  [T, I, J]
- */
-export declare const IDLTopType: IDLReferenceType;
 export declare const IDLPointerType: IDLPrimitiveType;
 export declare const IDLVoidType: IDLPrimitiveType;
 export declare const IDLBooleanType: IDLPrimitiveType;
@@ -306,6 +299,7 @@ export declare function getPackageName(node: IDLNode): string;
 export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): boolean;
 export declare function getNamespaceName(a: IDLEntry): string;
 export type QNPattern = "package.namespace.name" | "namespace.name" | "name";
+export declare function deriveQualifiedNameFrom(name: string, from: IDLNode): string;
 export declare function getQualifiedName(a: IDLNode, pattern: QNPattern): string;
 export declare function getFQName(a: IDLNode): string;
 export declare function createVersion(value: string[], nodeInitializer?: IDLNodeInitializer): IDLVersion;
@@ -367,9 +361,6 @@ export declare function printNamespace(idl: IDLNamespace): PrintedLine[];
 export declare function printCallback(idl: IDLCallback): PrintedLine[];
 export declare function printScoped(idl: IDLEntry): PrintedLine[];
 export declare function printInterface(idl: IDLInterface): PrintedLine[];
-export declare function getSuperType(idl: IDLInterface): IDLReferenceType | undefined;
-export declare function getSuperTypes(idl: IDLInterface): IDLReferenceType[] | undefined;
-export declare function hasSuperType(idl: IDLInterface): boolean;
 export declare function printEnumMember(idl: IDLEnumMember): PrintedLine[];
 export declare function printEnum(idl: IDLEnum, skipInitializers: boolean): PrintedLine[];
 export declare function printTypedef(idl: IDLTypedef): PrintedLine[];

package/build/lib/src/idl.js

@@ -76,10 +76,12 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
+    IDLExtendedAttributes["TraceKey"] = "TraceKey";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
+    IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 export var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -95,7 +97,7 @@ export var IDLInterfaceSubkind;
     IDLInterfaceSubkind[IDLInterfaceSubkind["Tuple"] = 3] = "Tuple";
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 export function forEachChild(node, cbEnter, cbLeave) {
-    var _a, _b;
+    var _a, _b, _c;
     const cleanup = cbEnter(node);
     switch (node.kind) {
         case IDLKind.File:
@@ -163,7 +165,10 @@ export function forEachChild(node, cbEnter, cbLeave) {
             node.typeArguments.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
-        case IDLKind.ReferenceType:
+        case IDLKind.ReferenceType: {
+            (_c = node.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
         case IDLKind.Import:
@@ -179,6 +184,7 @@ export function forEachChild(node, cbEnter, cbLeave) {
 }
 /** Updates tree in place! */
 function updateEachChild(node, op, cbLeave) {
+    var _a;
     const old = node;
     node = op(old);
     if (node.kind !== old.kind) {
@@ -261,7 +267,11 @@ function updateEachChild(node, op, cbLeave) {
             concrete.typeArguments = concrete.typeArguments.map(it => updateEachChild(it, op, cbLeave));
             break;
         }
-        case IDLKind.ReferenceType:
+        case IDLKind.ReferenceType: {
+            const concrete = node;
+            concrete.typeArguments = (_a = concrete.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
         case IDLKind.Import:
@@ -392,15 +402,6 @@ export function createOptionalType(element, nodeInitializer) {
     }
     return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
-/**
- * This placeholder is used when a class has no superclass.
- * Examples:
- *  class definition:               inheritance:
- * `C extends T`                  :  [T]
- * `C implements T`               :  [Top, T]
- * `C extends T implements I, J`  :  [T, I, J]
- */
-export const IDLTopType = createReferenceType("__TOP__");
 // must match with toIDLType in deserialize.ts
 export const IDLPointerType = createPrimitiveType('pointer');
 export const IDLVoidType = createPrimitiveType('void');
@@ -435,15 +436,10 @@ export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuff
 export function createNamespace(name, members, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function isSpecialNodes(node) {
-    return node === IDLTopType
-        || node === IDLObjectType
-        || isPrimitiveType(node);
-}
 export function linkParentBack(node) {
     const parentStack = [];
     updateEachChild(node, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return node;
         }
         if (parentStack.length) {
@@ -456,7 +452,7 @@ export function linkParentBack(node) {
         parentStack.push(node);
         return node;
     }, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return;
         }
         parentStack.pop();
@@ -509,6 +505,9 @@ export function isInPackage(entry, packageName, exactMatch = false) {
 export function getNamespaceName(a) {
     return getNamespacesPathFor(a).map(it => it.name).join('.');
 }
+export function deriveQualifiedNameFrom(name, from) {
+    return [...getPackageClause(from), ...getNamespacesPathFor(from).map(it => it.name), name].join(".");
+}
 export function getQualifiedName(a, pattern) {
     const result = [];
     if ("package.namespace.name" === pattern)
@@ -889,7 +888,10 @@ export function printParameters(parameters) {
     return (_b = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.map(it => nameWithType(it, it.isVariadic, it.isOptional))) === null || _a === void 0 ? void 0 : _a.join(", ")) !== null && _b !== void 0 ? _b : "";
 }
 export function printConstructor(idl) {
-    return [`constructor(${printParameters(idl.parameters)});`];
+    return [
+        ...printExtendedAttributes(idl, 1),
+        `constructor(${printParameters(idl.parameters)});`
+    ];
 }
 export function nameWithType(idl, isVariadic = false, isOptional = false) {
     const type = printType(idl.type);
@@ -955,6 +957,7 @@ export const attributesToQuote = new Set([
     IDLExtendedAttributes.DtsTag,
     IDLExtendedAttributes.Import,
     IDLExtendedAttributes.Interfaces,
+    IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
 ]);
@@ -1031,28 +1034,10 @@ export function printScoped(idl) {
     throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
 }
 function printInterfaceInherit(idl) {
-    var _a;
     if (idl.inheritance.length === 0) {
         return "";
     }
-    const inheritance = [...idl.inheritance];
-    const types = [];
-    if (idl.subkind === IDLInterfaceSubkind.Class) {
-        if (inheritance[0] !== IDLTopType) {
-            const ref = clone(inheritance[0]);
-            (_a = ref.extendedAttributes) !== null && _a !== void 0 ? _a : (ref.extendedAttributes = []);
-            if (!hasExtAttribute(ref, IDLExtendedAttributes.Extends)) {
-                ref.extendedAttributes = ref.extendedAttributes.concat([
-                    { name: IDLExtendedAttributes.Extends }
-                ]);
-            }
-            types.push(`${printType(ref)}`);
-            inheritance.shift();
-        }
-    }
-    inheritance.forEach(type => {
-        types.push(printType(type));
-    });
+    const types = idl.inheritance.map(type => printType(type));
     return ": " + types.join(', ');
 }
 export function printInterface(idl) {
@@ -1070,25 +1055,6 @@ export function printInterface(idl) {
         .concat(printedIndentDec)
         .concat(["};"]);
 }
-export function getSuperType(idl) {
-    if (!idl.inheritance)
-        return undefined;
-    const parent = idl.inheritance[0];
-    return parent && parent !== IDLTopType ? parent : undefined;
-}
-export function getSuperTypes(idl) {
-    if (!idl.inheritance)
-        return undefined;
-    if (idl.inheritance[0] == IDLTopType) {
-        return idl.inheritance.length == 1 ? undefined : idl.inheritance.slice(1);
-    }
-    else {
-        return idl.inheritance.length == 0 ? undefined : idl.inheritance;
-    }
-}
-export function hasSuperType(idl) {
-    return isDefined(getSuperType(idl));
-}
 export function printEnumMember(idl) {
     const type = printType(idl.type);
     const initializer = idl.initializer === undefined

package/build/lib/src/idlize.js

@@ -53,6 +53,8 @@ export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = fal
             console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
             return [];
         }
+    }).sort((a, b) => {
+        return path.basename(a).localeCompare(path.basename(b));
     });
 }
 function fileExists(fileName) {

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

@@ -40,9 +40,11 @@ export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isExternalType";
 export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
+export * from "./peer-generation/getSuperType";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

package/build/lib/src/index.js

@@ -54,9 +54,11 @@ export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isExternalType";
 export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
+export * from "./peer-generation/getSuperType";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

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

@@ -3,7 +3,8 @@ export declare enum LayoutNodeRole {
     PEER = 0,
     INTERFACE = 1,
     GLOBAL = 2,
-    COMPONENT = 3
+    COMPONENT = 3,
+    SERIALIZER = 4
 }
 export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function';
 export interface LayoutTargetDescription {
@@ -13,11 +14,13 @@ export interface LayoutTargetDescription {
 }
 export interface LayoutManagerStrategy {
     resolve(target: LayoutTargetDescription): string;
+    handwrittenPackage(): string;
 }
 export declare class LayoutManager {
     private strategy;
     constructor(strategy: LayoutManagerStrategy);
     resolve(target: LayoutTargetDescription): string;
+    handwrittenPackage(): string;
     static Empty(): LayoutManager;
 }
 //# sourceMappingURL=LayoutManager.d.ts.map

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

@@ -18,6 +18,7 @@ export var LayoutNodeRole;
     LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
     LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
     LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
+    LayoutNodeRole[LayoutNodeRole["SERIALIZER"] = 4] = "SERIALIZER";
 })(LayoutNodeRole || (LayoutNodeRole = {}));
 export class LayoutManager {
     constructor(strategy) {
@@ -26,9 +27,12 @@ export class LayoutManager {
     resolve(target) {
         return this.strategy.resolve(target);
     }
+    handwrittenPackage() {
+        return this.strategy.handwrittenPackage();
+    }
     ////////////////////////////////////////////////////////////////////
     static Empty() {
-        return new LayoutManager({ resolve: () => '' });
+        return new LayoutManager({ resolve: () => '', handwrittenPackage: () => '' });
     }
 }
 //# sourceMappingURL=LayoutManager.js.map

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

@@ -9,7 +9,8 @@ export declare class MaterializedField {
     argConvertor: ArgConvertor;
     outArgConvertor?: ArgConvertor | undefined;
     isNullableOriginalTypeField?: boolean | undefined;
-    constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined);
+    extraMethodName: string | undefined;
+    constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
 }
 export declare class MaterializedMethod extends PeerMethod {
     implementationParentName: string;
@@ -29,6 +30,9 @@ export declare class MaterializedMethod extends PeerMethod {
     getImplementationName(): string;
     tsReturnType(): idl.IDLType | undefined;
     getPrivateMethod(): MaterializedMethod;
+    withReturnType(returnType: idl.IDLType): MaterializedMethod;
+    setOverloadIndex(index: number): void;
+    getOverloadPostfix(): string;
 }
 export declare function copyMaterializedMethod(method: MaterializedMethod, overrides: {
     method?: Method;
@@ -42,12 +46,12 @@ export declare class MaterializedClass implements PeerClassBase {
     readonly interfaces: idl.IDLReferenceType[] | undefined;
     readonly generics: string[] | undefined;
     readonly fields: MaterializedField[];
-    readonly ctor: MaterializedMethod | undefined;
+    readonly ctors: MaterializedMethod[];
     readonly finalizer: MaterializedMethod | undefined;
     readonly methods: MaterializedMethod[];
     readonly needBeGenerated: boolean;
     readonly taggedMethods: idl.IDLMethod[];
-    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctor: MaterializedMethod | undefined, // undefined when used for global functions
+    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctors: MaterializedMethod[], // zero size when used for global functions
     finalizer: MaterializedMethod | undefined, // undefined when used for global functions
     methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
     getComponentName(): string;

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

@@ -18,11 +18,12 @@ import { capitalize } from '../util';
 import { qualifiedName } from './idl/common';
 import { PeerMethod } from './PeerMethod';
 export class MaterializedField {
-    constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField) {
+    constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField, extraMethodName = undefined) {
         this.field = field;
         this.argConvertor = argConvertor;
         this.outArgConvertor = outArgConvertor;
         this.isNullableOriginalTypeField = isNullableOriginalTypeField;
+        this.extraMethodName = extraMethodName;
     }
 }
 export class MaterializedMethod extends PeerMethod {
@@ -88,6 +89,20 @@ export class MaterializedMethod extends PeerMethod {
         }
         return privateMethod;
     }
+    withReturnType(returnType) {
+        const s = this.method.signature;
+        const argNames = s.args.map((_, i) => s.argName(i));
+        const signature = new NamedMethodSignature(returnType, s.args, argNames, s.defaults, s.argsModifiers, s.printHints);
+        const method = copyMethod(this.method, { signature: signature });
+        return copyMaterializedMethod(this, { method: method });
+    }
+    setOverloadIndex(index) {
+        this.overloadIndex = index;
+    }
+    getOverloadPostfix() {
+        var _a;
+        return `${(_a = this.overloadIndex) !== null && _a !== void 0 ? _a : ""}`;
+    }
 }
 export function copyMaterializedMethod(method, overrides) {
     var _a;
@@ -96,7 +111,7 @@ export function copyMaterializedMethod(method, overrides) {
     return copied;
 }
 export class MaterializedClass {
-    constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctor, // undefined when used for global functions
+    constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctors, // zero size when used for global functions
     finalizer, // undefined when used for global functions
     methods, needBeGenerated = true, taggedMethods = []) {
         this.decl = decl;
@@ -107,7 +122,7 @@ export class MaterializedClass {
         this.interfaces = interfaces;
         this.generics = generics;
         this.fields = fields;
-        this.ctor = ctor;
+        this.ctors = ctors;
         this.finalizer = finalizer;
         this.methods = methods;
         this.needBeGenerated = needBeGenerated;

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

@@ -8,6 +8,7 @@ import { BuilderClass } from './BuilderClass';
 import { MaterializedClass } from './Materialized';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
+import { NativeModuleType } from '../LanguageWriters/common';
 export interface GlobalScopeDeclarations {
     methods: idl.IDLMethod[];
     constants: idl.IDLConstant[];
@@ -10252,6 +10253,7 @@ export declare const lenses: {
 };
 export declare class PeerLibrary implements LibraryInterface {
     language: Language;
+    interopNativeModule: NativeModuleType;
     readonly useMemoM3: boolean;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
@@ -10265,8 +10267,8 @@ export declare class PeerLibrary implements LibraryInterface {
     readonly builderClasses: Map<string, BuilderClass>;
     get buildersToGenerate(): BuilderClass[];
     readonly materializedClasses: Map<string, MaterializedClass>;
-    get materializedToGenerate(): MaterializedClass[];
-    constructor(language: Language, useMemoM3?: boolean);
+    get orderedMaterialized(): MaterializedClass[];
+    constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
@@ -10284,6 +10286,7 @@ export declare class PeerLibrary implements LibraryInterface {
     private referenceCache;
     enableCache(): void;
     resolveTypeReference(type: idl.IDLReferenceType, singleStep?: boolean): idl.IDLEntry | undefined;
+    private resolveTypeReferenceUncached;
     private _useFallback;
     disableFallback(): void;
     resolveNamedNode(target: string[], pov?: idl.IDLNode | undefined): idl.IDLEntry | undefined;