@idlizer/core 2.0.37 → 2.0.38

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

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

@@ -0,0 +1,174 @@
+/*
+ * 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

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

package/build/lib/src/configMerge.js

@@ -0,0 +1,42 @@
+/*
+ * 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

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

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

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

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

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

@@ -0,0 +1,55 @@
+/*
+ * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.37",
+  "version": "2.0.38",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {