@idlizer/core 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

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

@@ -17,22 +17,21 @@ import * as idl from '../idl';
 import { resolveNamedNode } from '../resolveNamedNode';
 import { Language } from '../Language';
 import { createLanguageWriter } from '../LanguageWriters';
-import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
-import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
-import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
 import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
 import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
-import { isInIdlizeInternal } from '../idlize';
+import { isInIdlizeInternal } from '../idl';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
+import { toIdlType } from '../from-idl/deserialize';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -106,8 +105,6 @@ export class PeerLibrary {
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
-        this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
-        this.interopNameConvertorInstance = new CppNameConvertor(this);
         this._useFallback = true;
     }
     createLanguageWriter(language) {
@@ -117,7 +114,6 @@ export class PeerLibrary {
         switch (language) {
             case Language.TS: return new TSTypeNameConvertor(this);
             case Language.ARKTS: return new ETSTypeNameConvertor(this);
-            case Language.JAVA: return new JavaTypeNameConvertor(this);
             case Language.CJ: return new CJTypeNameConvertor(this);
             case Language.CPP: return new CppConvertor(this);
             case Language.KOTLIN: return new KotlinTypeNameConvertor(this);
@@ -157,7 +153,7 @@ export class PeerLibrary {
         return this.files.find(it => it.fileName === filename);
     }
     mapType(type) {
-        return this.targetNameConvertorInstance.convert(type);
+        return this.createTypeNameConvertor(this.language).convert(type);
     }
     enableCache() {
         this.referenceCache = new Map();
@@ -287,17 +283,17 @@ export class PeerLibrary {
         }
         if (idl.isPrimitiveType(type)) {
             switch (type) {
-                case idl.IDLI8Type: return new NumericConvertor(param, type);
-                case idl.IDLU8Type: return new NumericConvertor(param, type);
-                case idl.IDLI16Type: return new NumericConvertor(param, type);
-                case idl.IDLU16Type: return new NumericConvertor(param, type);
-                case idl.IDLI32Type: return new NumericConvertor(param, type);
-                case idl.IDLU32Type: return new NumericConvertor(param, type);
-                case idl.IDLI64Type: return new NumericConvertor(param, type);
-                case idl.IDLU64Type: return new NumericConvertor(param, type);
-                case idl.IDLF16Type: return new NumericConvertor(param, type);
-                case idl.IDLF32Type: return new NumericConvertor(param, type);
-                case idl.IDLF64Type: return new NumericConvertor(param, type);
+                case idl.IDLI8Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU8Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI64Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU64Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF64Type: return new NumericConvertor(this, param, type);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
                 case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
@@ -320,10 +316,10 @@ export class PeerLibrary {
             // TODO: this types are not references! NativeModulePrinter must be fixed
             switch (type.name.replaceAll('%TEXT%:', '')) { // this is really bad stub, to fix legacy references
                 case 'KBoolean': return new BooleanConvertor(param);
-                case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
-                case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
-                case 'KLong': return new NumericConvertor(param, idl.IDLI64Type);
-                case 'KDouble': return new NumericConvertor(param, idl.IDLF64Type);
+                case 'KInt': return new NumericConvertor(this, param, idl.IDLI32Type);
+                case 'KFloat': return new NumericConvertor(this, param, idl.IDLF32Type);
+                case 'KLong': return new NumericConvertor(this, param, idl.IDLI64Type);
+                case 'KDouble': return new NumericConvertor(this, param, idl.IDLF64Type);
                 case 'KStringPtr': return new StringConvertor(param);
                 case 'number': return new NumberConvertor(param);
                 case 'KPointer': return new PointerConvertor(param);
@@ -333,7 +329,7 @@ export class PeerLibrary {
             }
             const decl = this.resolveTypeReference(type);
             if (decl && isImportAttr(decl) || !decl && isImportAttr(type))
-                return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+                return new ImportTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type));
             return this.declarationConvertor(param, type, decl);
         }
         if (idl.isUnionType(type)) {
@@ -347,7 +343,7 @@ export class PeerLibrary {
         }
         if (idl.isTypeParameterType(type)) {
             // TODO: unlikely correct.
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true, `<${type.name}>`);
+            return new CustomTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type), true, `<${type.name}>`);
         }
         throw new Error(`Cannot convert: ${type.kind}`);
     }
@@ -359,11 +355,11 @@ export class PeerLibrary {
         if (customConv)
             return customConv;
         if (!declaration) {
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), false, this.targetNameConvertorInstance.convert(type)); // assume some predefined type
+            return new CustomTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type), false, this.createTypeNameConvertor(this.language).convert(type)); // assume some predefined type
         }
         const declarationName = declaration.name;
         if (isImportAttr(declaration)) {
-            return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+            return new ImportTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type));
         }
         if (idl.isImport(declaration)) {
             const target = this.resolveImport(declaration);
@@ -374,6 +370,10 @@ export class PeerLibrary {
                 return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
             }
         }
+        if (idl.hasExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize)) {
+            const targetRef = idl.createReferenceType(idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
+            return new TransformOnSerializeConvertor(param, this, declaration, targetRef);
+        }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
         }
@@ -384,10 +384,8 @@ export class PeerLibrary {
             return new CallbackConvertor(this, param, declaration, this.interopNativeModule);
         }
         if (idl.isTypedef(declaration)) {
-            if (isCyclicTypeDef(declaration)) {
-                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
-                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
-            }
+            if (forceTypedefAsResource(type, declaration))
+                return new ObjectConvertor(param, type);
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
@@ -425,9 +423,6 @@ export class PeerLibrary {
         }
         return undefined;
     }
-    getInteropName(node) {
-        return this.interopNameConvertorInstance.convert(node);
-    }
     toDeclaration(type) {
         switch (type) {
             case idl.IDLAnyType: return ArkCustomObject;
@@ -459,9 +454,12 @@ export class PeerLibrary {
             if (!decl) {
                 warn(`undeclared type ${idl.DebugUtils.debugPrintType(type)}`);
             }
-            if (decl && idl.isTypedef(decl) && isCyclicTypeDef(decl)) {
-                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
-                return ArkCustomObject;
+            if (decl && idl.isTypedef(decl) && forceTypedefAsResource(type, decl)) {
+                return idl.IDLObjectType;
+            }
+            if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
+                const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
+                return this.toDeclaration(type);
             }
             return !decl ? ArkCustomObject // assume some builtin type
                 : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
@@ -490,7 +488,34 @@ export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {
     return name.replace(prefix, "");
 }
+function forceTypedefAsResource(type, decl) {
+    if (generatorConfiguration().forceResource.includes(idl.getFQName(decl)))
+        return true;
+    if (isCyclicTypeDef(decl)) {
+        warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
+        return true;
+    }
+    return false;
+}
 function isCyclicTypeDef(decl) {
-    return idl.isReferenceType(decl.type) && idl.isNamedNode(decl.type) && decl.type.name == decl.name;
+    return checkCyclicType(idl.getFQName(decl), decl.type);
+}
+function checkCyclicType(fqn, type) {
+    if (idl.isReferenceType(type) && idl.isNamedNode(type) && idl.getFQName(type) == fqn)
+        return true;
+    if (idl.isOptionalType(type) && checkCyclicType(fqn, type.type))
+        return true;
+    if (idl.isUnionType(type) && checkCyclicTypes(fqn, type.types))
+        return true;
+    if (idl.isContainerType(type) && checkCyclicTypes(fqn, type.elementType))
+        return true;
+    return false;
+}
+function checkCyclicTypes(fqn, types) {
+    for (const t of types) {
+        if (checkCyclicType(fqn, t))
+            return true;
+    }
+    return false;
 }
 //# sourceMappingURL=PeerLibrary.js.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -26,6 +26,11 @@ export declare class CJDeclarationNameConvertor extends DeclarationNameConvertor
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: CJDeclarationNameConvertor;
 }
+export declare class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: KotlinDeclarationNameConvertor;
+}
 export declare class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSFeatureNameConvertor;
@@ -35,6 +40,7 @@ export declare class CJFeatureNameConvertor extends DeclarationNameConvertor {
     static readonly I: CJFeatureNameConvertor;
 }
 export declare class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: KotlinFeatureNameConvertor;
 }

package/build/lib/src/peer-generation/idl/IdlNameConvertor.js

@@ -14,6 +14,7 @@
  */
 import * as idl from "../../idl";
 import { Language } from "../../Language";
+import { removePoints } from "../../util";
 export class DeclarationNameConvertor {
     convertImport(decl) {
         console.warn("Imports are not implemented yet");
@@ -70,6 +71,15 @@ export class CJDeclarationNameConvertor extends DeclarationNameConvertor {
     }
 }
 CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
+export class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
+    convertEnum(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
+}
+KotlinDeclarationNameConvertor.I = new KotlinDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
         const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
@@ -86,25 +96,27 @@ export class CJFeatureNameConvertor extends DeclarationNameConvertor {
 }
 CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
 export class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
     convertEnum(decl) {
-        return decl.name;
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
     }
 }
 KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
 export function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
-        case Language.JAVA:
         case Language.CPP:
         case Language.TS: return DeclarationNameConvertor.I;
         case Language.CJ: CJDeclarationNameConvertor.I;
+        case Language.KOTLIN: KotlinDeclarationNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
 export function createFeatureNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSFeatureNameConvertor.I;
-        case Language.JAVA:
         case Language.CPP:
         case Language.TS: return TSFeatureNameConvertor.I;
         case Language.CJ: return CJFeatureNameConvertor.I;

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

@@ -25,7 +25,7 @@ export function isMaterialized(declaration, resolver) {
     if (generatorConfiguration().forceResource.includes(declaration.name)) {
         return false;
     }
-    if (generatorConfiguration().forceMaterialized.includes(declaration.name)) {
+    if (generatorConfiguration().forceMaterialized.some(r => r === idl.getFQName(declaration))) {
         return true;
     }
     // TODO: rework this

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

@@ -16,4 +16,6 @@ export declare function getModuleFor(packageName: string): ModuleConfiguration;
 export declare function currentModule(): ModuleConfiguration;
 export declare function isInCurrentModule(node: idl.IDLNode): boolean;
 export declare function isInCurrentModule(packageName: string): boolean;
+export declare function isInStdlibModule(node: idl.IDLNode): boolean;
+export declare function isInStdlibModule(packageName: string): boolean;
 //# sourceMappingURL=modules.d.ts.map

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

@@ -1,5 +1,12 @@
 import { generatorConfiguration } from "../config";
 import * as idl from "../idl";
+const stdlibModule = {
+    name: "__stdlib",
+    packages: [""],
+    useFoldersLayout: false,
+    external: true,
+    tsLikePackage: "__stdlib"
+};
 const modulesCache = new Map();
 /**
  * Is source submodule of target.
@@ -39,7 +46,7 @@ function getApplicableModuleFor(packageName) {
     if (applicableModules.length === 0) {
         if (packageName === '') {
             console.error("WARNING: use current module for empty package");
-            return currentModule();
+            return stdlibModule;
         }
         if (packageName.startsWith(`idlize.`)) {
             return currentModule();
@@ -66,4 +73,10 @@ export function isInCurrentModule(nodeOrPackage) {
         : getModuleFor(nodeOrPackage);
     return generatorConfiguration().moduleName == module.name;
 }
+export function isInStdlibModule(nodeOrPackage) {
+    const module = typeof nodeOrPackage === 'string'
+        ? getModuleFor(nodeOrPackage)
+        : getModuleFor(nodeOrPackage);
+    return stdlibModule.name == module.name;
+}
 //# sourceMappingURL=modules.js.map

package/build/lib/src/transformers/GenericTransformer.js

@@ -12,12 +12,9 @@ export function inplaceGenerics(node, resolver, options) {
         if (idl.isReferenceType(child))
             candidates.push(child);
     });
-    if (idl.isReferenceType(node)) {
-        candidates.push(node);
-    }
     options !== null && options !== void 0 ? options : (options = {});
     (_a = options.ignore) !== null && _a !== void 0 ? _a : (options.ignore = []);
-    options.ignore.push(ignoreConfigRule, ignoreBuilderClassRule, createIgnoreMaterializedRule(resolver));
+    options.ignore.push(ignoreConfigRule, ignoreBuilderClassRule, createIgnoreMaterializedRule(resolver), createIgnoreResourceRule(resolver));
     candidates.forEach(it => inplaceReferenceGenerics(it, resolver, options));
 }
 export function isInplacedGeneric(entry) {
@@ -52,7 +49,19 @@ function ignoreBuilderClassRule(node) {
     return idl.isInterface(node) && isBuilderClass(node);
 }
 function createIgnoreMaterializedRule(resolver) {
-    return (node) => idl.isInterface(node) && isMaterialized(node, resolver);
+    return (node) => idl.isInterface(node) && isMaterialized(node, resolver) && !idl.hasExtAttribute(node, idl.IDLExtendedAttributes.TransformOnSerialize);
+}
+function createIgnoreResourceRule(resolver) {
+    return (node) => {
+        if (!idl.isReferenceType(node)) {
+            return false;
+        }
+        const declaration = resolver.resolveTypeReference(node);
+        if (!declaration) {
+            return false;
+        }
+        return generatorConfiguration().forceResource.includes(declaration.name);
+    };
 }
 function monomorphisedEntryName(typedEntry, typeArguments) {
     return typedEntry.name + "_" + typeArguments.map(generateSyntheticIdlNodeName).join("_");
@@ -86,6 +95,7 @@ function monomorphizeEntry(typedEntry, typeArguments) {
         name: idl.IDLExtendedAttributes.TypeArguments,
         value: typeArguments.map(type => idl.printType(type)).join("|"),
     });
+    inplaceRemoveMeaninglessFields(monomorphizedEntry);
     return monomorphizedEntry;
 }
 function hasTypeParameterTypeChild(node) {
@@ -98,6 +108,7 @@ function hasTypeParameterTypeChild(node) {
 }
 function inplaceReferenceGenerics(ref, resolver, options) {
     var _a, _b;
+    inplaceDefaultReferenceGenerics(ref, resolver);
     if (!((_a = ref.typeArguments) === null || _a === void 0 ? void 0 : _a.length) || hasTypeParameterTypeChild(ref)) {
         return;
     }
@@ -117,6 +128,7 @@ function inplaceReferenceGenerics(ref, resolver, options) {
         const monomorphizedEntry = monomorphizeEntry(resolved, ref.typeArguments);
         insertEntryNearTo(monomorphizedEntry, resolved);
         inplaceGenerics(monomorphizedEntry, resolver);
+        correctTransformOnSerialize(resolver, monomorphizedEntry, ref.typeArguments, options);
     }
     ref.name = inplacedRef.name;
     ref.typeArguments = undefined;
@@ -138,4 +150,57 @@ function insertEntryNearTo(entry, anchor) {
     parentEntries.splice(parentEntries.indexOf(anchor), 0, entry);
     idl.linkParentBack(anchor.parent);
 }
+// when generic declaration has TransformOnSerialize attribute, for monomorphized entry we must update that attribute that will look
+// at monomorphized TransformOnSerialize
+function correctTransformOnSerialize(resolver, monomorphizedEntry, typeArguments, options) {
+    const targetName = idl.getExtAttribute(monomorphizedEntry, idl.IDLExtendedAttributes.TransformOnSerialize);
+    if (targetName === undefined) {
+        return;
+    }
+    const targetType = toIdlType("", targetName);
+    if (idl.isReferenceType(targetType)) {
+        targetType.typeArguments = typeArguments;
+        inplaceReferenceGenerics(targetType, resolver, options);
+        idl.updateExtAttribute(monomorphizedEntry, idl.IDLExtendedAttributes.TransformOnSerialize, targetType.name);
+    }
+}
+function inplaceDefaultReferenceGenerics(node, resolver) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const decl = resolver.resolveTypeReference(node);
+    if (!decl) {
+        console.error(`Can not resolve reference for inplacing default generics ${node.name} in file ${(_a = node.fileName) !== null && _a !== void 0 ? _a : '<unknown>'}`);
+        return;
+    }
+    if (!idl.isTypedef(decl) && !idl.isInterface(decl) && !idl.isCallback(decl)) {
+        return;
+    }
+    if (((_c = (_b = decl.typeParameters) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > ((_e = (_d = node.typeArguments) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0)) {
+        const defaults = (_h = (_g = (_f = decl.extendedAttributes) === null || _f === void 0 ? void 0 : _f.find(it => it.name === idl.IDLExtendedAttributes.TypeParametersDefaults)) === null || _g === void 0 ? void 0 : _g.typesValue) !== null && _h !== void 0 ? _h : [];
+        while (defaults.length < decl.typeParameters.length) {
+            defaults.unshift(undefined);
+        }
+        (_j = node.typeArguments) !== null && _j !== void 0 ? _j : (node.typeArguments = []);
+        while (decl.typeParameters.length > node.typeArguments.length) {
+            if (defaults[node.typeArguments.length] === undefined) {
+                throw new Error(`Can not validate reference to ${idl.getFQName(decl)} declaration: reference has not enough generic arguments or declaration does not have enough default generic values`);
+            }
+            node.typeArguments.push(defaults[node.typeArguments.length]);
+        }
+    }
+}
+function isMeaninglessFieldType(type) {
+    return type === idl.IDLVoidType || type === idl.IDLUndefinedType;
+}
+function inplaceRemoveMeaninglessFields(node, options = { recursive: true }) {
+    if (options.recursive) {
+        idl.forEachChild(node, child => inplaceRemoveMeaninglessFields(child, { recursive: false }));
+        return;
+    }
+    if (idl.isInterface(node)) {
+        node.properties = node.properties.filter(it => !isMeaninglessFieldType(it.type));
+    }
+    if (idl.isMethod(node)) {
+        node.parameters = node.parameters.filter(it => !isMeaninglessFieldType(it.type));
+    }
+}
 //# sourceMappingURL=GenericTransformer.js.map

package/build/lib/src/transformers/NullTransformer.d.ts

@@ -1,4 +1,3 @@
 import * as idl from "../idl";
-export declare const NULL_REFERENCE = "idlize.stdlib.Null";
 export declare function inplaceNullsAsUndefined(node: idl.IDLNode): void;
 //# sourceMappingURL=NullTransformer.d.ts.map

package/build/lib/src/transformers/NullTransformer.js

@@ -1,6 +1,5 @@
 import * as idl from "../idl";
 import { generateSyntheticUnionName } from "../peer-generation/idl/common";
-export const NULL_REFERENCE = "idlize.stdlib.Null";
 export function inplaceNullsAsUndefined(node) {
     idl.updateEachChild(node, (child) => {
         var _a;
@@ -29,6 +28,6 @@ export function inplaceNullsAsUndefined(node) {
     });
 }
 function isNullReference(node) {
-    return idl.isReferenceType(node) && node.name === NULL_REFERENCE;
+    return idl.isReferenceType(node) && node.name === idl.IDLNullTypeName;
 }
 //# sourceMappingURL=NullTransformer.js.map

package/build/lib/src/transformers/OnSerializeTransformer.d.ts

@@ -0,0 +1,3 @@
+import * as idl from "../idl";
+export declare function inplaceTransformOnSerializeFromConfig(node: idl.IDLNode): void;
+//# sourceMappingURL=OnSerializeTransformer.d.ts.map

package/build/lib/src/transformers/OnSerializeTransformer.js

@@ -0,0 +1,19 @@
+import { generatorConfiguration } from "../config";
+import * as idl from "../idl";
+export function inplaceTransformOnSerializeFromConfig(node) {
+    inplaceTransformOnSerializeSelf(node);
+    idl.updateEachChild(node, child => {
+        inplaceTransformOnSerializeSelf(child);
+        return child;
+    });
+}
+function inplaceTransformOnSerializeSelf(node) {
+    if (!idl.isEntry(node)) {
+        return;
+    }
+    const transformation = generatorConfiguration().transformOnSerialize.find(it => it.from === idl.getFQName(node));
+    if (transformation !== undefined) {
+        idl.updateExtAttribute(node, idl.IDLExtendedAttributes.TransformOnSerialize, transformation.to);
+    }
+}
+//# sourceMappingURL=OnSerializeTransformer.js.map

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

@@ -1,30 +1,7 @@
-import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
-export interface NameWithType {
-    name?: ts.DeclarationName;
-    type?: ts.TypeNode;
-}
-/** True if this is visible outside this file, false otherwise */
-export declare function isNodePublic(node: ts.Node): boolean;
-export declare function nameOrNull(name: ts.EntityName | ts.DeclarationName | undefined): string | undefined;
-export declare function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration;
-export declare function asString(node: ts.Node | undefined): string;
+import { LibraryInterface } from './LibraryInterface';
 export declare function arrayAt<T>(array: T[] | undefined, index: number): T | undefined;
-export declare function getComment(sourceFile: ts.SourceFile, node: ts.Node): string;
-export declare function getSymbolByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
-export declare function getDeclarationsByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function findRealDeclarations(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function getExportedDeclarationNameByDecl(declaration: ts.NamedDeclaration): string | undefined;
-export declare function getExportedDeclarationNameByNode(typechecker: ts.TypeChecker, node: ts.Node): string | undefined;
-export declare function isReadonly(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isExport(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAbstract(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isStatic(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAsync(modifierLikes: ts.NodeArray<ts.ModifierLike> | readonly ts.Modifier[] | undefined): boolean;
-export declare function isPrivate(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isProtected(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function getLineNumberString(sourceFile: ts.SourceFile, position: number): string;
 export declare function isDefined<T>(value: T | null | undefined): value is T;
 export declare function capitalize(string: string): string;
 export declare function capitalizeConstantName(string: string): string;
@@ -34,22 +11,9 @@ export type stringOrNone = string | undefined;
 export declare function toSet(option: string | undefined): Set<string>;
 export declare function getOrPut<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 export declare function indentedBy(input: string, indentedBy: number): string;
-export declare function typeOrUndefined(type: ts.TypeNode): ts.TypeNode;
 export declare function forEachExpanding<T>(array: T[], action: (element: T) => void): void;
-export declare function isTypeParamSuitableType(type: ts.TypeNode): boolean;
-export declare function heritageTypes(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.TypeReferenceNode[];
-export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.NamedDeclaration[];
-export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
-export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
 export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
 export declare function zipStrip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
-export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
-export declare function identName(node: ts.Node | undefined): string | undefined;
-export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
-export declare const defaultCompilerOptions: ts.CompilerOptions;
-export declare function serializerBaseMethods(): string[];
-export declare function getNameWithoutQualifiersRight(node: ts.EntityName | undefined): string | undefined;
-export declare function getNameWithoutQualifiersLeft(node: ts.EntityName | undefined): string | undefined;
 export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: boolean): string;
 export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
@@ -60,9 +24,7 @@ export declare function renameDtsToComponent(fileName: string, language: Languag
 export declare function renameDtsToInterfaces(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
-export declare function importTypeName(type: ts.ImportTypeNode, asType?: boolean): string;
 export declare function throwException(message: string): never;
-export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclaration): string;
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
@@ -95,5 +57,14 @@ export declare function getExtractor(target: idl.IDLInterface, lang: Language, t
     receiver?: string;
     method: string;
 };
+export declare function getTransformer(library: LibraryInterface, from: idl.IDLNode, to: idl.IDLNode): {
+    receiver?: string;
+    method: string;
+};
+export declare function removePoints(s: string): string;
+export declare function scanDirectory(dir: string, fileFilter: (file: string) => boolean, recursive?: boolean): string[];
+export declare function scanInputDirs(inputDirs: string[]): string[];
+export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
+export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
 export {};
 //# sourceMappingURL=util.d.ts.map