@idlizer/core 2.0.35 → 2.0.36

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

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorConfiguration, generatorTypePrefix } from "../config";
+import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppNameConvertor } from "./convertors/CppConvertors";
@@ -894,7 +894,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorConfiguration().TypePrefix}${this.declaration.name}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;

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

@@ -236,6 +236,7 @@ export declare abstract class LanguageWriter {
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;

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

@@ -91,6 +91,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;

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

@@ -376,6 +376,10 @@ export class CJLanguageWriter extends LanguageWriter {
     writeTypeDeclaration(decl) {
         throw new Error(`writeTypeDeclaration not implemented`);
     }
+    writeConstant(constName, constType, constVal) {
+        const namespacePrefix = this.namespaceStack.join('_');
+        this.print(`const ${namespacePrefix}${constName}: ${this.getNodeName(constType)} = ${constVal !== null && constVal !== void 0 ? constVal : ''}`);
+    }
     writeMethodImplementation(method, op) {
         this.writeDeclaration(method.name, method.signature, method.modifiers, " {");
         this.pushIndent();

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

@@ -47,6 +47,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
     writeTypeDeclaration(decl: IDLTypedef): void;
+    writeConstant(constName: string, constType: IDLType, constVal?: string): void;
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -223,6 +223,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writeTypeDeclaration(decl) {
         throw new Error(`writeTypeDeclaration not implemented`);
     }
+    writeConstant(constName, constType, constVal) {
+        this.print(`${this.getNodeName(constType)} ${constName}${constVal ? ' = ' + constVal : ''};`);
+    }
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -42,6 +42,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;

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

@@ -155,6 +155,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     writeTypeDeclaration(decl) {
         throw new Error(`Type declarations do not exist in Java, use something else`);
     }
+    writeConstant(constName, constType, constVal) {
+        throw new Error("writeConstant for Java is not implemented yet.");
+    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
     }

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

@@ -55,6 +55,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
     makeNull(): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;

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

@@ -240,6 +240,9 @@ export class TSLanguageWriter extends LanguageWriter {
         const typeParams = ((_a = decl.typeParameters) === null || _a === void 0 ? void 0 : _a.length) ? `<${decl.typeParameters.join(",").replace("[]", "")}>` : "";
         this.print(`export type ${decl.name}${typeParams} = ${type};`);
     }
+    writeConstant(constName, constType, constVal) {
+        this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
+    }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import { generatorTypePrefix } from "../config";
+import { asPromise } from "../idl";
 import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
 import { capitalize, isDefined } from "../util";
 import { PrimitiveTypesInstance } from "./PrimitiveType";
@@ -78,7 +79,9 @@ export class PeerMethod {
         const receiver = this.generateReceiver();
         if (receiver)
             args.unshift(`${receiver.argType} ${receiver.argName}`);
-        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS))
+        if (!!asPromise(this.method.signature.returnType))
+            args.unshift(`${generatorTypePrefix()}AsyncWorkerPtr asyncWorker`);
+        if (!!asPromise(this.method.signature.returnType) || ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)))
             args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
         return args;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.35",
+  "version": "2.0.36",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.6",
+    "@koalaui/interop": "1.5.7",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },

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

@@ -1,36 +0,0 @@
-import * as idl from '../idl';
-import { IdlNameConvertor, NodeConvertor } from "./nameConvertor";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
-export interface ConvertResult {
-    text: string;
-    noPrefix: boolean;
-}
-export declare class InteropConvertor implements NodeConvertor<ConvertResult> {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
-    private make;
-    convertNode(node: idl.IDLNode): ConvertResult;
-    convertNamespace(node: idl.IDLNamespace): ConvertResult;
-    convertInterface(node: idl.IDLInterface): ConvertResult;
-    convertEnum(node: idl.IDLEnum): ConvertResult;
-    convertTypedef(node: idl.IDLTypedef): ConvertResult;
-    convertCallback(node: idl.IDLCallback): ConvertResult;
-    convertMethod(node: idl.IDLMethod): ConvertResult;
-    convertConstant(node: idl.IDLConstant): ConvertResult;
-    convertOptional(type: idl.IDLOptionalType): ConvertResult;
-    convertUnion(type: idl.IDLUnionType): ConvertResult;
-    convertContainer(type: idl.IDLContainerType): ConvertResult;
-    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
-    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
-    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
-    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
-    private enumName;
-    private computeTargetTypeLiteralName;
-}
-export declare class InteropNameConvertor implements IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    private readonly interopConvertor;
-    constructor(resolver: ReferenceResolver);
-    convert(node: idl.IDLNode): string;
-}
-//# sourceMappingURL=InteropConvertor.d.ts.map

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

@@ -1,174 +0,0 @@
-/*
- * Copyright (c) 2025 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as idl from '../idl';
-import { convertNode } from "./nameConvertor";
-import { generatorConfiguration } from '../config';
-import { capitalize } from '../util';
-import { qualifiedName } from '../peer-generation/idl/common';
-import { maybeTransformManagedCallback } from './ArgConvertors';
-export class InteropConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-    }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
-    }
-    convertNode(node) {
-        return convertNode(this, node);
-    }
-    convertNamespace(node) {
-        throw new Error("Internal error: namespaces are not allowed on the interop layer");
-    }
-    convertInterface(node) {
-        switch (node.subkind) {
-            case idl.IDLInterfaceSubkind.AnonymousInterface:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
-            case idl.IDLInterfaceSubkind.Interface:
-            case idl.IDLInterfaceSubkind.Class:
-                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
-                    return this.make(node.name, true);
-                }
-                return this.make(node.name);
-            case idl.IDLInterfaceSubkind.Tuple:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
-        }
-    }
-    convertEnum(node) {
-        return this.make(this.enumName(node));
-    }
-    convertTypedef(node) {
-        return this.make(node.name);
-    }
-    convertCallback(node) {
-        return this.make(generatorConfiguration().param("LibraryPrefix") + node.name, true);
-    }
-    convertMethod(node) {
-        return this.make(node.name);
-    }
-    convertConstant(node) {
-        return this.make(node.name);
-    }
-    /////////////////////////////////////////////////////////////////////////////////////////
-    convertOptional(type) {
-        return this.convertNode(type.type);
-    }
-    convertUnion(type) {
-        return this.make(type.name, false);
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
-        }
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, true);
-            }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    convertImport(type, _) {
-        return this.make(idl.IDLCustomObjectType.name);
-    }
-    convertTypeReference(type) {
-        var _a;
-        const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                return this.make('CustomObject');
-        }
-        if (generatorConfiguration().paramArray("knownParameterized").includes(refName)) {
-            return this.make('CustomObject');
-        }
-        let decl = this.resolver.toDeclaration(type);
-        if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
-        }
-        if (idl.isType(decl)) {
-            if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
-            }
-            return this.convertNode(decl);
-        }
-        let res = this.convertNode(decl);
-        if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
-        return res;
-    }
-    convertTypeParameter(type) {
-        return this.make('CustomObject');
-    }
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLVoidType: return this.make('void', true);
-            case idl.IDLI8Type: return this.make(`Int8`);
-            case idl.IDLU8Type: return this.make(`UInt8`);
-            case idl.IDLI16Type: return this.make(`Int16`);
-            case idl.IDLU16Type: return this.make(`UInt16`);
-            case idl.IDLI32Type: return this.make(`Int32`);
-            case idl.IDLU32Type: return this.make(`UInt32`);
-            case idl.IDLI64Type: return this.make(`Int64`);
-            case idl.IDLU64Type: return this.make(`UInt64`);
-            case idl.IDLF32Type: return this.make(`Float32`);
-            case idl.IDLF64Type: return this.make(`Float64`);
-            case idl.IDLNumberType: return this.make(`Number`);
-            case idl.IDLStringType: return this.make(`String`);
-            case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
-            case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLLengthType: return this.make(`Length`);
-            case idl.IDLFunctionType: return this.make(`Function`);
-            case idl.IDLDate: return this.make(`Date`);
-            case idl.IDLBufferType: return this.make('Buffer');
-            case idl.IDLPointerType: return this.make('Pointer');
-        }
-        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    enumName(target) {
-        return qualifiedName(target, "_");
-    }
-    computeTargetTypeLiteralName(decl) {
-        const map = new Map();
-        for (const prop of decl.properties) {
-            const type = this.convertNode(prop.type);
-            const values = map.has(type.text) ? map.get(type.text) : [];
-            values.push(prop.name);
-            map.set(type.text, values);
-        }
-        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
-        return `Literal_${names.join('_')}`;
-    }
-}
-export class InteropNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.interopConvertor = new InteropConvertor(resolver);
-    }
-    convert(node) {
-        return this.interopConvertor.convertNode(node).text;
-    }
-}
-//# sourceMappingURL=InteropConvertor.js.map

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

@@ -1,2 +0,0 @@
-export declare function deepMergeConfig<T extends object>(defaults: T, custom: Partial<T>): T;
-//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2025 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function isObject(i) {
-    if (typeof i !== 'object')
-        return false;
-    if (Array.isArray(i))
-        return false;
-    return true;
-}
-export function deepMergeConfig(defaults, custom) {
-    if (custom === undefined)
-        return defaults;
-    const result = Object.assign({}, defaults);
-    for (const key in custom) {
-        if (Object.prototype.hasOwnProperty.call(custom, key)) {
-            const defaultValue = result[key];
-            const customValue = custom[key];
-            if (isObject(defaultValue) && isObject(customValue)) {
-                Object.assign(result, { [key]: deepMergeConfig(defaultValue, customValue) });
-            }
-            else {
-                if (isObject(defaultValue))
-                    throw new Error("Replacing default object value with custom non-object");
-                Object.assign(result, { [key]: customValue });
-            }
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=configMerge.js.map

package/build/lib/src/peer-generation/LanguageWriters/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./nameConvertor";
-//# sourceMappingURL=index.d.ts.map

package/build/lib/src/peer-generation/LanguageWriters/index.js

@@ -1,2 +0,0 @@
-export * from "./nameConvertor";
-//# sourceMappingURL=index.js.map

package/build/lib/src/peer-generation/LanguageWriters/nameConvertor.d.ts

@@ -1,25 +0,0 @@
-import * as idl from '../../idl';
-export interface IdlNameConvertor {
-    convert(node: idl.IDLNode): string;
-}
-export interface TypeConvertor<T> {
-    convertOptional(type: idl.IDLOptionalType): T;
-    convertUnion(type: idl.IDLUnionType): T;
-    convertContainer(type: idl.IDLContainerType): T;
-    convertImport(type: idl.IDLReferenceType, importClause: string): T;
-    convertTypeReference(type: idl.IDLReferenceType): T;
-    convertTypeParameter(type: idl.IDLTypeParameterType): T;
-    convertPrimitiveType(type: idl.IDLPrimitiveType): T;
-}
-export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
-export interface DeclarationConvertor<T> {
-    convertInterface(node: idl.IDLInterface): T;
-    convertEnum(node: idl.IDLEnum): T;
-    convertTypedef(node: idl.IDLTypedef): T;
-    convertCallback(node: idl.IDLCallback): T;
-}
-export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>, decl: idl.IDLEntry): T;
-export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
-}
-export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
-//# sourceMappingURL=nameConvertor.d.ts.map

package/build/lib/src/peer-generation/LanguageWriters/nameConvertor.js

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as idl from '../../idl';
-export function convertType(convertor, type) {
-    if (idl.isOptionalType(type))
-        return convertor.convertOptional(type);
-    if (idl.isUnionType(type))
-        return convertor.convertUnion(type);
-    if (idl.isContainerType(type))
-        return convertor.convertContainer(type);
-    if (idl.isReferenceType(type)) {
-        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
-        return importAttr
-            ? convertor.convertImport(type, importAttr)
-            : convertor.convertTypeReference(type);
-    }
-    if (idl.isTypeParameterType(type))
-        return convertor.convertTypeParameter(type);
-    if (idl.isPrimitiveType(type))
-        return convertor.convertPrimitiveType(type);
-    throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
-}
-export function convertDeclaration(convertor, decl) {
-    if (idl.isInterface(decl))
-        return convertor.convertInterface(decl);
-    if (idl.isEnum(decl))
-        return convertor.convertEnum(decl);
-    if (idl.isEnumMember(decl))
-        return convertor.convertEnum(decl.parent);
-    if (idl.isTypedef(decl))
-        return convertor.convertTypedef(decl);
-    if (idl.isCallback(decl))
-        return convertor.convertCallback(decl);
-    throw new Error(`Unknown declaration type ${decl.kind ? idl.IDLKind[decl.kind] : "(undefined kind)"}`);
-}
-export function convertNode(convertor, node) {
-    if (idl.isEntry(node))
-        return convertDeclaration(convertor, node);
-    if (idl.isType(node))
-        return convertType(convertor, node);
-    throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
-}
-//# sourceMappingURL=nameConvertor.js.map