@idlizer/core 2.1.10-arktscgen-3 → 2.1.10-arktscgen-4

package/build/lib/src/idl.js

@@ -74,6 +74,8 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
     IDLExtendedAttributes["Optional"] = "Optional";
+    IDLExtendedAttributes["UnionOnlyNull"] = "OptionalOnlyNull";
+    IDLExtendedAttributes["UnionWithNull"] = "OptionalWithNull";
     IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
     IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
     IDLExtendedAttributes["Predefined"] = "Predefined";
@@ -85,11 +87,13 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
+    IDLExtendedAttributes["TypeParametersDefaults"] = "TypeParametersDefaults";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
     IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
     IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
+    IDLExtendedAttributes["TransformOnSerialize"] = "TransformOnSerialize";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 export var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -441,6 +445,7 @@ export const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 export const IDLFunctionType = createPrimitiveType('Function');
 export const IDLCustomObjectType = createPrimitiveType('CustomObject');
 export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
+export const IDLNullTypeName = "idlize.stdlib.Null";
 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 });
 }
@@ -870,23 +875,29 @@ export function unescapeKeyword(name) {
 const printedIndentInc = "[[indent-inc]]";
 const printedIndentDec = "[[indent-dec]]";
 export function printType(type, options) {
+    var _a;
     if (!type)
         throw new Error("Missing type");
     if (isInterface(type))
         return type.name;
-    if (isOptionalType(type))
-        return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    if (isOptionalType(type)) {
+        if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
+            return `(${printType(type.type)} or ${IDLNullTypeName})`;
+        else if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull))
+            return `(${printType(type.type)} or ${IDLUndefinedType.name} or${IDLNullTypeName})`;
+        else
+            return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    }
     if (isPrimitiveType(type))
         return type.name;
     if (isContainerType(type))
         return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
     if (isReferenceType(type)) {
-        const extAttrs = type.extendedAttributes ? Array.from(type.extendedAttributes) : [];
         if (type.typeArguments)
-            extAttrs.push({ name: IDLExtendedAttributes.TypeArguments, value: type.typeArguments.map(it => printType(it)).join(",") });
-        if (!extAttrs.length)
+            updateExtAttribute(type, IDLExtendedAttributes.TypeArguments, type.typeArguments.map(it => printType(it)).join(","));
+        if (!((_a = type.extendedAttributes) === null || _a === void 0 ? void 0 : _a.length))
             return type.name;
-        let res = `[${quoteAttributeValues(extAttrs)}] ${type.name}`;
+        let res = `[${quoteAttributeValues(type.extendedAttributes)}] ${type.name}`;
         if (options === null || options === void 0 ? void 0 : options.bracketsAroundReferenceTypeWithExtAttrs)
             return `(${res})`;
         return res;
@@ -956,18 +967,31 @@ export function printExtendedAttributes(idl, indentLevel) {
             break;
     }
     const attributes = Array.from(idl.extendedAttributes || []);
-    if (typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length)
+    if ((typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeParameters))
         attributes.push({ name: IDLExtendedAttributes.TypeParameters, value: typeParameters.join(",") });
-    if (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length)
+    if ((typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeArguments))
         attributes.push({ name: IDLExtendedAttributes.TypeArguments, value: typeArguments.map(it => printType(it)).join(",") });
     if (idl.documentation) {
         let docs = {
             name: IDLExtendedAttributes.Documentation,
             value: idl.documentation
         };
-        attributes.push(docs);
+        attributes.unshift(docs);
     }
-    const attrSpec = quoteAttributeValues(attributes);
+    // Deduplicate
+    const names = new Set();
+    const actualAttributes = [];
+    for (const attr of attributes) {
+        if (names.has(attr.name)) {
+            continue;
+        }
+        names.add(attr.name);
+        actualAttributes.push(attr);
+    }
+    if (actualAttributes.length == 0) {
+        return [];
+    }
+    const attrSpec = quoteAttributeValues(actualAttributes);
     return attrSpec ? [`[${attrSpec}]`] : [];
 }
 export const attributesToQuote = new Set([
@@ -979,6 +1003,7 @@ export const attributesToQuote = new Set([
     IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
+    IDLExtendedAttributes.TypeParametersDefaults,
 ]);
 function quoteAttributeValues(attributes) {
     return attributes === null || attributes === void 0 ? void 0 : attributes.map(it => {
@@ -1179,6 +1204,17 @@ export function getExtAttribute(node, name) {
     var _a, _b;
     return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.value;
 }
+export function removeExtAttribute(node, name) {
+    if (node.extendedAttributes) {
+        node.extendedAttributes = node.extendedAttributes.filter(it => it.name !== name);
+    }
+}
+export function updateExtAttribute(node, name, value) {
+    var _a;
+    removeExtAttribute(node, name);
+    (_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : (node.extendedAttributes = []);
+    node.extendedAttributes.push({ name, value });
+}
 export function getVerbatimDts(node) {
     let value = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
     return value ? value.substring(1, value.length - 1) : undefined;
@@ -1201,6 +1237,16 @@ export function decomposeQualifiedName(type) {
     }
     return [undefined, typeName];
 }
+export function qualifiedNameStartsWith(node, template) {
+    const name = Array.isArray(node) ? node : getFQName(node).split(".");
+    if (name.length < template.length)
+        return false;
+    for (let i = 0; i < template.length; i++) {
+        if (name[i] != template[i])
+            return false;
+    }
+    return true;
+}
 export function maybeUnwrapOptionalType(type) {
     if (isOptionalType(type)) {
         return type.type;

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

@@ -51,13 +51,15 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
+export * from "./transformers/OnSerializeTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDLFile, addSyntheticType, resolveSyntheticType, IDLTokenInfoMap } from "./from-idl/deserialize";
+export { parseIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, ConfigTypeInfer, ConfigSchema, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -65,13 +65,15 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
+export * from "./transformers/OnSerializeTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { parseIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map

package/build/lib/src/languageSpecificKeywords.js

@@ -35,7 +35,7 @@ export const CJKeywords = new Set([
     'break', 'is', 'as', 'in', 'match',
     'from', 'where', 'extend', 'spawn',
     'synchronized', 'macro', 'quote', 'true',
-    /*'false', */ 'static', 'public', 'private',
+    'false', 'static', 'public', 'private',
     'protected', 'override', 'redef', 'abstract',
     'open', 'operator', 'foreign', 'inout',
     'prop', 'mut', 'unsafe', 'get', 'set', 'type'

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

@@ -17,7 +17,7 @@ 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 { 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 { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -33,6 +33,7 @@ import { isInIdlizeInternal } from '../idlize';
 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())
@@ -280,10 +281,10 @@ export class PeerLibrary {
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
-            return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
+            return new OptionConvertor(this, param, idl.isOptionalType(type) ? type : idl.createOptionalType(type));
         }
         if (idl.isOptionalType(type)) {
-            return new OptionConvertor(this, param, type.type);
+            return new OptionConvertor(this, param, type);
         }
         if (idl.isPrimitiveType(type)) {
             switch (type) {
@@ -374,6 +375,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);
         }
@@ -420,7 +425,8 @@ export class PeerLibrary {
             case `Record`:
                 return new CustomTypeConvertor(param, "Record", false, "Record<string, string>");
             case `Optional`:
-                return new OptionConvertor(this, param, type.typeArguments[0]);
+                throw new Error("Not expected to have reference type named Optional");
+            // return new OptionConvertor(this, param, type.typeArguments![0])
         }
         return undefined;
     }
@@ -462,6 +468,10 @@ export class PeerLibrary {
                 warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
                 return ArkCustomObject;
             }
+            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)
                     : decl;

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

@@ -1,5 +1,13 @@
 import { ModuleConfiguration } from "../config";
 import * as idl from "../idl";
+/**
+ * Is source submodule of target.
+ * Every source is submodule if target is empty string
+ * @example `isSubmodule("a.b.c", "a") === true`
+ * @example `isSubmodule("a", "a.b.c") === false`
+ * @example `isSubmodule("a.b.cd", "a.b.c") === false`
+ */
+export declare function isSubmodule(source: string, target: string): boolean;
 export declare function isInModule(node: idl.IDLNode, module: ModuleConfiguration): boolean;
 export declare function isInModule(packageName: string, module: ModuleConfiguration): boolean;
 export declare function isInExternalModule(node: idl.IDLNode): boolean;
@@ -8,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,10 +1,29 @@
 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.
+ * Every source is submodule if target is empty string
+ * @example `isSubmodule("a.b.c", "a") === true`
+ * @example `isSubmodule("a", "a.b.c") === false`
+ * @example `isSubmodule("a.b.cd", "a.b.c") === false`
+ */
+export function isSubmodule(source, target) {
+    return source === target
+        || target === ""
+        || source.startsWith(target + '.');
+}
 export function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(idl.getPackageName(nodeOrPackage), module);
-    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+    return module.packages.some(modulePackage => isSubmodule(nodeOrPackage, modulePackage));
 }
 export function isInExternalModule(node) {
     var _a;
@@ -27,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();
@@ -54,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

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

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

@@ -0,0 +1,33 @@
+import * as idl from "../idl";
+import { generateSyntheticUnionName } from "../peer-generation/idl/common";
+export function inplaceNullsAsUndefined(node) {
+    idl.updateEachChild(node, (child) => {
+        var _a;
+        if (idl.isOptionalType(child)) {
+            if (idl.isUnionType(child.type) && child.type.types.some(isNullReference)) {
+                child.type.types = child.type.types.filter(it => !isNullReference(it));
+                child.type.name = generateSyntheticUnionName(child.type.types);
+                if (child.type.types.length === 1) {
+                    child.type = child.type.types[0];
+                }
+                (_a = child.extendedAttributes) !== null && _a !== void 0 ? _a : (child.extendedAttributes = []);
+                child.extendedAttributes.push({ name: idl.IDLExtendedAttributes.UnionWithNull });
+                return child;
+            }
+        }
+        else if (idl.isUnionType(child)) {
+            if (child.types.some(isNullReference)) {
+                child.types = child.types.filter(it => !isNullReference(it));
+                child.name = generateSyntheticUnionName(child.types);
+                return idl.createOptionalType(child.types.length > 1 ? child : child.types[0], { extendedAttributes: [{
+                            name: idl.IDLExtendedAttributes.UnionOnlyNull
+                        }] });
+            }
+        }
+        return child;
+    });
+}
+function isNullReference(node) {
+    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,6 +1,7 @@
 import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
+import { LibraryInterface } from './LibraryInterface';
 export interface NameWithType {
     name?: ts.DeclarationName;
     type?: ts.TypeNode;
@@ -95,5 +96,9 @@ 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 {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -17,7 +17,7 @@ import * as fs from "fs";
 import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
-import { isInExternalModule } from './peer-generation/modules';
+import { getModuleFor, isInExternalModule } from './peer-generation/modules';
 import { getInternalClassName, getInternalClassQualifiedName } from './peer-generation/Materialized';
 /** True if this is visible outside this file, false otherwise */
 export function isNodePublic(node) {
@@ -693,8 +693,12 @@ export function sorted(array, key) {
 }
 export function mapLibraryName(node, lang, mapping, prefix = "@") {
     var _a, _b;
+    const module = getModuleFor(node);
+    if (module.tsLikePackage !== undefined) {
+        return `^` + module.tsLikePackage;
+    }
     const packageName = idl.getPackageName(node);
-    return (_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`;
+    return `^` + ((_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`);
 }
 function getExtractorClass(target, toPtr = true) {
     if (isInExternalModule(target)) {
@@ -716,4 +720,11 @@ export function getExtractor(target, lang, toPtr = true) {
     const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
     return { receiver, method };
 }
+export function getTransformer(library, from, to) {
+    const convertor = library.createTypeNameConvertor(Language.CPP);
+    return {
+        receiver: "extractors",
+        method: `transform_${convertor.convert(from)}_to_${convertor.convert(to)}`
+    };
+}
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-3",
+  "version": "2.1.10-arktscgen-4",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -33,16 +33,16 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.9",
-    "typescript": "4.9.5",
-    "@types/node": "^18.0.0"
+    "typescript": "4.9.5"
   },
   "devDependencies": {
     "@koalaui/harness": "1.7.6+devel",
     "@koalaui/ets-tsc": "4.9.5-r5",
     "@types/mocha": "^9.1.0",
     "mocha": "^9.2.2",
-    "ts-node": "^10.9.2"
+    "ts-node": "^10.9.2",
+    "@koalaui/interop": "1.7.9",
+    "@types/node": "^18.0.0"
   },
   "scripts": {
     "test": "mocha",