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

package/build/lib/src/LanguageWriters/ArgConvertors.d.ts

@@ -265,9 +265,9 @@ export declare class CustomTypeConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class OptionConvertor extends BaseArgConvertor {
-    type: idl.IDLType;
+    type: idl.IDLOptionalType;
     private readonly typeConvertor;
-    constructor(library: LibraryInterface, param: string, type: idl.IDLType);
+    constructor(library: LibraryInterface, param: string, type: idl.IDLOptionalType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): LanguageStatement;
     convertorCArg(param: string): string;

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

@@ -851,7 +851,7 @@ export class CustomTypeConvertor extends BaseArgConvertor {
 export class OptionConvertor extends BaseArgConvertor {
     // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
     constructor(library, param, type) {
-        let conv = library.typeConvertor(param, type);
+        let conv = library.typeConvertor(param, type.type);
         let currentConv = conv;
         while (currentConv instanceof ProxyConvertor) {
             currentConv = currentConv.convertor;
@@ -872,7 +872,7 @@ export class OptionConvertor extends BaseArgConvertor {
     }
     convertorSerialize(param, value, printer) {
         const valueValue = `${value}TmpValue`.replaceAll('.', '_');
-        return printer.makeCondition(printer.makeDefinedCheck(value), new BlockStatement([
+        return printer.makeCondition(printer.makeDefinedCheck(value, this.type), new BlockStatement([
             printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.OBJECT)])),
             printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true),
             this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer)
@@ -886,7 +886,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull(bufferName) : undefined, true, false)); // maybe change to generic None
+        statements.push(writer.makeAssign(bufferName, bufferType, writer.language === Language.CPP ? undefined : writer.makeNull(this.type), true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -900,10 +900,10 @@ export class OptionConvertor extends BaseArgConvertor {
         return writer.makeBlock(statements, false);
     }
     nativeType() {
-        return idl.createOptionalType(this.type);
+        return this.type;
     }
     interopType() {
-        return idl.createOptionalType(this.type);
+        return this.type;
     }
     isPointerType() {
         return true;

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -316,7 +316,7 @@ export declare abstract class LanguageWriter {
     writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
-    makeNull(value?: string): LanguageExpression;
+    makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeVoid(): LanguageExpression;
     makeLambdaReturn(expr?: LanguageExpression): LanguageStatement;
     makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName?: string): LanguageExpression;
@@ -330,7 +330,7 @@ export declare abstract class LanguageWriter {
     makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
     nativeReceiver(nativeModule: NativeModuleType): string;
-    abstract makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
+    abstract makeDefinedCheck(value: string, type?: idl.IDLOptionalType, isTag?: boolean): LanguageExpression;
     makeRuntimeTypeDefinedCheck(runtimeType: string): LanguageExpression;
     makeCondition(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement?: LanguageStatement, insideIfOp?: () => void, insideElseOp?: () => void): LanguageStatement;
     makeMultiBranchCondition(conditions: BranchStatement[], elseStatement?: LanguageStatement): LanguageStatement;

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

@@ -488,7 +488,7 @@ export class LanguageWriter {
     makeThis() {
         return new StringExpression("this");
     }
-    makeNull(value) {
+    makeNull(type) {
         return new StringExpression("null");
     }
     makeVoid() {

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

@@ -46,7 +46,15 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertOptional(type) {
-        return `${this.convert(type.type)} | undefined`;
+        if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull)) {
+            return `${this.convert(type.type)} | null`;
+        }
+        else if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionWithNull)) {
+            return `${this.convert(type.type)} | null | undefined`;
+        }
+        else {
+            return `${this.convert(type.type)} | undefined`;
+        }
     }
     convertUnion(type) {
         return type.types.

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

@@ -136,7 +136,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
     protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
-    makeNull(value?: string): LanguageExpression;
+    makeNull(): LanguageExpression;
     getTagType(): idl.IDLType;
     getRuntimeType(): idl.IDLType;
     makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;

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

@@ -527,7 +527,7 @@ export class CJLanguageWriter extends LanguageWriter {
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
         return this.makeStatement(this.makeMethodCall(keyAccessor, "add", [this.makeString(key), this.makeString(value)]));
     }
-    makeNull(value) {
+    makeNull() {
         return this.makeUndefined();
     }
     getTagType() {

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

@@ -101,7 +101,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
-    makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
+    makeDefinedCheck(value: string, type?: idl.IDLOptionalType, isTag?: boolean): LanguageExpression;
     makeSetUnionSelector(value: string, index: string): LanguageStatement;
     makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;

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

@@ -347,7 +347,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writePrintLog(message) {
         this.print(`printf("${message}\\n");`);
     }
-    makeDefinedCheck(value, isTag) {
+    makeDefinedCheck(value, type, isTag) {
         return this.makeString(isTag ? `${value} != ${PrimitiveTypeList.UndefinedTag}`
             : `runtimeType(${value}) != ${PrimitiveTypeList.UndefinedRuntime}`);
     }

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

@@ -66,7 +66,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
-    makeNull(): LanguageExpression;
+    makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeThrowError(message: string): LanguageStatement;
@@ -80,7 +80,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeDefinedCheck(value: string): LanguageExpression;
+    makeDefinedCheck(value: string, type?: idl.IDLOptionalType): LanguageExpression;
     makeTupleAlloc(option: string): LanguageStatement;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;

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

@@ -295,7 +295,9 @@ export class TSLanguageWriter extends LanguageWriter {
         const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
         this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
-    makeNull() {
+    makeNull(type) {
+        if (type && idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull))
+            return new StringExpression("null");
         return new StringExpression("undefined");
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
@@ -352,7 +354,15 @@ export class TSLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt) {
         return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
     }
-    makeDefinedCheck(value) {
+    makeDefinedCheck(value, type) {
+        if (type) {
+            if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionWithNull)) {
+                return this.makeString(`${value} !== undefined && ${value} !== null`);
+            }
+            else if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull)) {
+                return this.makeString(`${value} !== null`);
+            }
+        }
         return this.makeString(`${value} !== undefined`);
     }
     makeTupleAlloc(option) {

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

@@ -55,6 +55,8 @@ export declare enum IDLExtendedAttributes {
     Interfaces = "Interfaces",
     NativeModule = "NativeModule",
     Optional = "Optional",
+    UnionOnlyNull = "OptionalOnlyNull",
+    UnionWithNull = "OptionalWithNull",
     OriginalEnumMemberName = "OriginalEnumMemberName",
     OriginalGenericName = "OriginalGenericName",
     Predefined = "Predefined",

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";

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

@@ -51,6 +51,7 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

package/build/lib/src/index.js

@@ -65,6 +65,7 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

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

@@ -280,10 +280,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) {
@@ -420,7 +420,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;
     }

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;

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

@@ -1,10 +1,22 @@
 import { generatorConfiguration } from "../config";
 import * as idl from "../idl";
 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;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,34 @@
+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;
+        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 === NULL_REFERENCE;
+}
+//# sourceMappingURL=NullTransformer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-3",
+  "version": "2.1.10-arktscgen-3a",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -33,7 +33,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.9",
+    "@koalaui/interop": "1.7.10",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },