@idlizer/core 2.1.10-arktscgen-9 → 2.1.10-arktscgen-10

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

@@ -14,25 +14,6 @@
  */
 import * as idl from "../../idl";
 import { Language } from "../../Language";
-import { capitalize } from "../../util";
-export function generateSyntheticIdlNodeName(type) {
-    if (idl.isPrimitiveType(type))
-        return capitalize(type.name);
-    if (idl.isContainerType(type)) {
-        const typeArgs = type.elementType.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_");
-        switch (type.containerKind) {
-            case "sequence": return "Array_" + typeArgs;
-            case "record": return "Map_" + typeArgs;
-            case "Promise": return "Promise_" + typeArgs;
-            default: throw new Error(`Unknown container type ${idl.DebugUtils.debugPrintType(type)}`);
-        }
-    }
-    if (idl.isNamedNode(type))
-        return type.name.split('.').map(capitalize).join('_');
-    if (idl.isOptionalType(type))
-        return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
-    throw `Can not compute type name of ${idl.IDLKind[type.kind]}`;
-}
 export function qualifiedName(decl, languageOrDelimiter, pattern) {
     if (!idl.isNamedNode(decl))
         throw new Error("internal error, name required for no-named node");
@@ -70,20 +51,17 @@ export function sanitizeGenerics(genericDeclarationString) {
     }
     return genericDeclarationString.trim();
 }
-export function generateSyntheticUnionName(types) {
-    return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
-}
 export function generateSyntheticFunctionParameterName(parameter) {
     if (parameter.isOptional) {
-        return generateSyntheticIdlNodeName(idl.createOptionalType(parameter.type));
+        return idl.generateSyntheticIdlNodeName(idl.createOptionalType(parameter.type));
     }
-    return generateSyntheticIdlNodeName(parameter.type);
+    return idl.generateSyntheticIdlNodeName(parameter.type);
 }
 export function generateSyntheticFunctionName(parameters, returnType, options) {
     let prefix = (options === null || options === void 0 ? void 0 : options.isAsync) ? "AsyncCallback" : "Callback";
     const names = (options === null || options === void 0 ? void 0 : options.nameConvertor) !== undefined
         ? parameters.map(it => options.nameConvertor.convert(it.type)).concat(options.nameConvertor.convert(returnType))
-        : parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
+        : parameters.map(generateSyntheticFunctionParameterName).concat(idl.generateSyntheticIdlNodeName(returnType));
     return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
 }
 export function isImportAttr(decl) {

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

@@ -1,6 +1,10 @@
 import * as idl from '../idl';
+import { Language } from '../Language';
 import { ReferenceResolver } from './ReferenceResolver';
 export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare function isStaticMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare function isMaterializedType(type: idl.IDLType, resolver: ReferenceResolver): boolean;
+export declare function getInternalClassName(name: string): string;
+export declare function getInternalClassQualifiedName(target: idl.IDLEntry, pattern?: idl.QNPattern, language?: Language): string;
+export declare function getMaterializedFileName(name: string): string;
 //# sourceMappingURL=isMaterialized.d.ts.map

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

@@ -14,7 +14,9 @@
  */
 import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
+import { capitalize } from '../util';
 import { getSuper } from './getSuperType';
+import { qualifiedName } from './idl/common';
 export function isMaterialized(declaration, resolver) {
     var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
@@ -96,4 +98,14 @@ export function isMaterializedType(type, resolver) {
         return false;
     return (idl.isInterface(decl) && isMaterialized(decl, resolver));
 }
+export function getInternalClassName(name) {
+    return `${name}Internal`;
+}
+export function getInternalClassQualifiedName(target, pattern = "package.namespace.name", language) {
+    return getInternalClassName(qualifiedName(target, language !== null && language !== void 0 ? language : ".", pattern));
+}
+export function getMaterializedFileName(name) {
+    const pascalCase = name.split('_').map(x => capitalize(x)).join('');
+    return `Ark${pascalCase}Materialized`;
+}
 //# sourceMappingURL=isMaterialized.js.map

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

@@ -1,28 +1,2 @@
-import { TypeConvertor } from "../LanguageWriters";
-import { IDLImport, IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
-import { LanguageExpression, LanguageWriter } from "../LanguageWriters/LanguageWriter";
-import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
-import { LibraryInterface } from "../LibraryInterface";
-import { ReferenceResolver } from "./ReferenceResolver";
-export declare class UnionFlattener implements TypeConvertor<IDLType[]> {
-    private resolver;
-    constructor(resolver: ReferenceResolver);
-    convertImport(type: IDLImport): IDLType[];
-    convertUnion(type: IDLUnionType): IDLType[];
-    convertTypeReference(type: IDLReferenceType): IDLType[];
-    convertOptional(type: IDLOptionalType): IDLType[];
-    convertContainer(type: IDLContainerType): IDLType[];
-    convertTypeReferenceAsImport(type: IDLReferenceType, importClause: string): IDLType[];
-    convertPrimitiveType(type: IDLPrimitiveType): IDLType[];
-    convertTypeParameter(type: IDLTypeParameterType): IDLType[];
-}
-export declare class UnionRuntimeTypeChecker {
-    private convertors;
-    private conflictingConvertors;
-    private duplicateMembers;
-    constructor(convertors: ArgConvertor[]);
-    private checkConflicts;
-    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter, library: LibraryInterface, type?: IDLType): LanguageExpression;
-}
-export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
+export {};
 //# sourceMappingURL=unions.d.ts.map

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

@@ -12,103 +12,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as idl from '../idl';
-import { convertType } from "../LanguageWriters";
-import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
-import { collapseTypes } from "./idl/common";
-import { RuntimeType } from "../LanguageWriters/common";
-import { Language } from "../Language";
-export class UnionFlattener {
-    constructor(resolver) {
-        this.resolver = resolver;
-    }
-    convertImport(type) {
-        console.warn("Imports are not implemented yet");
-        return [];
-    }
-    convertUnion(type) {
-        return type.types.flatMap(it => convertType(this, it));
-    }
-    convertTypeReference(type) {
-        const decl = this.resolver.toDeclaration(type);
-        return isType(decl) && decl !== IDLCustomObjectType ? convertType(this, decl) : [type];
-    }
-    convertOptional(type) {
-        return [type.type, IDLUndefinedType];
-    }
-    convertContainer(type) {
-        return [type];
-    }
-    convertTypeReferenceAsImport(type, importClause) {
-        return [type];
-    }
-    convertPrimitiveType(type) {
-        return [type];
-    }
-    convertTypeParameter(type) {
-        return [type];
-    }
-}
-export class UnionRuntimeTypeChecker {
-    constructor(convertors) {
-        this.convertors = convertors;
-        this.conflictingConvertors = new Set();
-        this.duplicateMembers = new Set();
-        this.checkConflicts();
-    }
-    checkConflicts() {
-        const runtimeTypeConflicts = new Map();
-        this.convertors.forEach(conv => {
-            conv.runtimeTypes.forEach(rtType => {
-                const convertors = runtimeTypeConflicts.get(rtType);
-                if (convertors)
-                    convertors.push(conv);
-                else
-                    runtimeTypeConflicts.set(rtType, [conv]);
-            });
-        });
-        runtimeTypeConflicts.forEach((convertors, rtType) => {
-            if (convertors.length > 1) {
-                const allMembers = new Set();
-                if (rtType === RuntimeType.OBJECT) {
-                    convertors.forEach(convertor => {
-                        convertor.getMembers().forEach(member => {
-                            if (allMembers.has(member))
-                                this.duplicateMembers.add(member);
-                            allMembers.add(member);
-                        });
-                    });
-                }
-                convertors.forEach(convertor => {
-                    this.conflictingConvertors.add(convertor);
-                });
-            }
-        });
-    }
-    makeDiscriminator(value, convertorIndex, writer, library, type) {
-        let convertor = this.convertors[convertorIndex];
-        if (writer.language === Language.TS) {
-            const isArray = idl.IDLContainerUtils.isSequence(convertor.idlType);
-            if (isArray || this.conflictingConvertors.has(convertor)) {
-                // Check elements inside array
-                if (type && convertor.idlType != type) {
-                    convertor = library.typeConvertor("", type);
-                }
-                const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
-                if (discriminator)
-                    return discriminator;
-            }
-        }
-        return writer.makeString(writer.discriminate(value, convertorIndex, type !== null && type !== void 0 ? type : convertor.idlType, convertor.runtimeTypes));
-    }
-}
-export function flattenUnionType(library, type) {
-    if (isUnionType(type)) {
-        const unionFlattener = new UnionFlattener(library);
-        const allTypes = type.types.flatMap(it => convertType(unionFlattener, it));
-        const uniqueTypes = new Set(allTypes);
-        return uniqueTypes.size === allTypes.length ? type : collapseTypes(Array.from(uniqueTypes));
-    }
-    return type;
-}
+export {};
 //# sourceMappingURL=unions.js.map

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

@@ -1,3 +1,17 @@
+/*
+ * 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";
 import { IdlTransformer } from "./IdlTransformer";
 export function fqnTransformer(corpus, resolver) {

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

@@ -1,9 +1,7 @@
 import * as idl from "../idl";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 export declare function genericsTransformer(files: idl.IDLFile[], options: {
     ignore: ((node: idl.IDLNode) => boolean)[];
     ignoreGenerics: string[];
 }): idl.IDLFile[];
 export declare function isInplacedGeneric(entry: idl.IDLEntry): boolean;
-export declare function maybeRestoreGenerics(maybeTransformedGeneric: idl.IDLReferenceType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
 //# sourceMappingURL=GenericTransformer.d.ts.map

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

@@ -1,3 +1,17 @@
+/*
+ * 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 { generatorConfiguration } from "../config";
 import { toIdlType } from "../from-idl/deserialize";
 import * as idl from "../idl";
@@ -5,8 +19,8 @@ import { Language } from "../Language";
 import { StructureNameConvertor } from "../LanguageWriters/convertors/CppConvertors";
 import { isMaterialized } from "../peer-generation/isMaterialized";
 import { LayoutManager } from "../peer-generation/LayoutManager";
+import { toDeclaration } from "../peer-generation/PeerLibrary";
 import { createCachedReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { toDeclaration } from "../peer-generation/toDeclaration";
 import { IdlTransformer } from "./IdlTransformer";
 export function genericsTransformer(files, options) {
     const optionsResolver = createCachedReferenceResolver(files);
@@ -80,7 +94,7 @@ class DefaultGenericsTransformer extends IdlTransformer {
         this.resolver = resolver;
     }
     visit(node) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         if (idl.isReferenceType(node)) {
             const decl = this.resolver.resolveTypeReference(node);
             if (!decl) {
@@ -91,14 +105,14 @@ class DefaultGenericsTransformer extends IdlTransformer {
                 return this.visitEachChild(node);
             }
             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 = (_j = (_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 ? void 0 : _h.slice()) !== null && _j !== void 0 ? _j : [];
+                const defaults = (_k = (_j = (_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 ? void 0 : _h.slice()) === null || _j === void 0 ? void 0 : _j.map(it => this.visit(it))) !== null && _k !== void 0 ? _k : [];
                 while (defaults.length < decl.typeParameters.length) {
                     defaults.unshift(undefined);
                 }
-                const typeArguments = Array.from((_k = node.typeArguments) !== null && _k !== void 0 ? _k : []);
+                const typeArguments = Array.from((_l = node.typeArguments) !== null && _l !== void 0 ? _l : []);
                 while (decl.typeParameters.length > typeArguments.length) {
                     if (defaults[typeArguments.length] === undefined) {
-                        const declarationDetails = `${idl.getFQName(decl)}<${((_l = decl.typeParameters) !== null && _l !== void 0 ? _l : [])
+                        const declarationDetails = `${idl.getFQName(decl)}<${((_m = decl.typeParameters) !== null && _m !== void 0 ? _m : [])
                             .map((it, index) => `${it}${defaults[index] ? '=' + defaults[index] : ''}`)
                             .join(', ')}>`;
                         const referenceDetails = `${node.name}<${typeArguments.map(it => idl.printType(it)).join(", ")}>`;
@@ -247,20 +261,6 @@ class RemoveMeaninglessFieldsTransformer extends IdlTransformer {
 export function isInplacedGeneric(entry) {
     return idl.hasExtAttribute(entry, idl.IDLExtendedAttributes.OriginalGenericName);
 }
-export function maybeRestoreGenerics(maybeTransformedGeneric, resolver) {
-    if (idl.isReferenceType(maybeTransformedGeneric)) {
-        const resolved = resolver.resolveTypeReference(maybeTransformedGeneric);
-        return resolved ? maybeRestoreGenerics(resolved, resolver) : undefined;
-    }
-    if (maybeTransformedGeneric && idl.hasExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName)) {
-        const originalName = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
-        const typeArguments = idl.getExtAttributeTypesValue(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
-        if (!typeArguments)
-            throw new Error(`Can not restore original generic type arguments for ${originalName}: no type arguments`);
-        return idl.createReferenceType(originalName, typeArguments);
-    }
-    return undefined;
-}
 function ignoreConfigRule(ignoreGenerics) {
     return (node) => {
         return idl.isEntry(node) && ignoreGenerics.includes(idl.getFQName(node));

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

@@ -1,3 +1,17 @@
+/*
+ * 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 class IdlTransformer {
     visitEachChild(node) {

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

@@ -1,5 +1,18 @@
+/*
+ * 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";
-import { generateSyntheticUnionName } from "../peer-generation/idl/common";
 import { IdlTransformer } from "./IdlTransformer";
 export function nullsTransformer(files) {
     const transformer = new NullsTransformer();
@@ -11,7 +24,7 @@ class NullsTransformer extends IdlTransformer {
         if (idl.isOptionalType(node)) {
             if (idl.isUnionType(node.type) && node.type.types.some(isNullReference)) {
                 const unionTypes = node.type.types.filter(it => !isNullReference(it)).map(it => this.visit(it));
-                const unionName = generateSyntheticUnionName(unionTypes);
+                const unionName = idl.generateSyntheticUnionName(unionTypes);
                 const extendedAttributes = ((_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : [])
                     .concat({ name: idl.IDLExtendedAttributes.UnionWithNull });
                 return idl.createOptionalType(unionTypes.length === 1
@@ -26,7 +39,7 @@ class NullsTransformer extends IdlTransformer {
         else if (idl.isUnionType(node)) {
             if (node.types.some(isNullReference)) {
                 const unionTypes = node.types.filter(it => !isNullReference(it)).map(it => this.visit(it));
-                const unionName = generateSyntheticUnionName(unionTypes);
+                const unionName = idl.generateSyntheticUnionName(unionTypes);
                 return idl.createOptionalType(unionTypes.length === 1 ? unionTypes[0] : idl.createUnionType(unionTypes, unionName, idl.cloneNodeInitializer(node)), { extendedAttributes: [{ name: idl.IDLExtendedAttributes.UnionOnlyNull }] });
             }
         }

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

@@ -1,3 +1,17 @@
+/*
+ * 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";
 import { IdlTransformer } from "./IdlTransformer";
 export function transformOnSerializeTransformer(files, destinationGetter) {

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

@@ -0,0 +1,3 @@
+import * as idl from "../idl";
+export declare function throwsTransformer(files: idl.IDLFile[]): idl.IDLFile[];
+//# sourceMappingURL=ThrowsTransformer.d.ts.map

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

@@ -0,0 +1,51 @@
+/*
+ * 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";
+import { IdlTransformer } from "./IdlTransformer";
+export function throwsTransformer(files) {
+    assertNoThrowsReferences(files);
+    const transformer = new ThrowsTransformer();
+    return files.map(it => transformer.visit(it)).map(idl.linkParentBack);
+}
+function assertNoThrowsReferences(files) {
+    files.forEach(file => {
+        idl.forEachChild(file, node => {
+            if (idl.isReferenceType(node) && node.name === idl.IDLThrowsTypeName) {
+                throw new Error(`${idl.IDLThrowsTypeName} can be referenced only in throwsTransformer. If you want to make method throwable, please add 'Throws' extended attribute to the method.`);
+            }
+        });
+    });
+}
+class ThrowsTransformer extends IdlTransformer {
+    visit(node) {
+        if (idl.isMethod(node)) {
+            if (!idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Throws)) {
+                return this.visitEachChild(node);
+            }
+            if (idl.isContainerType(node.returnType) && node.returnType.containerKind === "Promise") {
+                // Promises are already includes `throws` by default and do not need to have additional generation
+                return this.visitEachChild(node);
+            }
+            return idl.createMethod(node.name, node.parameters, idl.createReferenceType(idl.IDLThrowsTypeName, [node.returnType]), {
+                isAsync: node.isAsync,
+                isFree: node.isFree,
+                isOptional: node.isOptional,
+                isStatic: node.isStatic,
+            }, idl.cloneNodeInitializer(node), node.typeParameters);
+        }
+        return this.visitEachChild(node);
+    }
+}
+//# sourceMappingURL=ThrowsTransformer.js.map

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

@@ -0,0 +1,7 @@
+import * as idl from "../idl";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export declare function maybeRestoreGenerics(maybeTransformedGeneric: idl.IDLReferenceType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
+export declare function isThrows(node: idl.IDLNode, resolver: ReferenceResolver): boolean;
+export declare function maybeRestoreThrows(node: idl.IDLNode, resolver: ReferenceResolver): idl.IDLType | undefined;
+export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
+//# sourceMappingURL=transformUtils.d.ts.map

package/build/lib/src/transformers/transformUtils.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 maybeRestoreGenerics(maybeTransformedGeneric, resolver) {
+    if (idl.isReferenceType(maybeTransformedGeneric)) {
+        const resolved = resolver.resolveTypeReference(maybeTransformedGeneric);
+        return resolved ? maybeRestoreGenerics(resolved, resolver) : undefined;
+    }
+    if (maybeTransformedGeneric && idl.hasExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName)) {
+        const originalName = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
+        const typeArguments = idl.getExtAttributeTypesValue(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
+        if (!typeArguments)
+            throw new Error(`Can not restore original generic type arguments for ${originalName}: no type arguments`);
+        return idl.createReferenceType(originalName, typeArguments);
+    }
+    return undefined;
+}
+export function isThrows(node, resolver) {
+    if (idl.isReferenceType(node)) {
+        const resolved = resolver.resolveTypeReference(node);
+        return resolved ? isThrows(resolved, resolver) : false;
+    }
+    return !!maybeRestoreThrows(node, resolver) ||
+        idl.isEntry(node) && idl.getFQName(node) === idl.IDLThrowsTypeName;
+}
+export function maybeRestoreThrows(node, resolver) {
+    if (idl.isReferenceType(node)) {
+        const resolved = resolver.resolveTypeReference(node);
+        return resolved ? maybeRestoreThrows(resolved, resolver) : undefined;
+    }
+    if (idl.isEntry(node)) {
+        const restored = maybeRestoreGenerics(node, resolver);
+        if (restored && restored.name === idl.IDLThrowsTypeName)
+            return restored.typeArguments[0];
+    }
+    return undefined;
+}
+export function maybeTransformManagedCallback(callback, library) {
+    if (callback.name === "CustomBuilder")
+        return library.resolveTypeReference(idl.createReferenceType("arkui.component.idlize.CustomNodeBuilder"));
+    return undefined;
+}
+//# sourceMappingURL=transformUtils.js.map

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

@@ -1,6 +1,4 @@
-import * as idl from "./idl";
 import { Language } from './Language';
-import { LibraryInterface } from './LibraryInterface';
 export declare function arrayAt<T>(array: T[] | undefined, index: number): T | undefined;
 export declare function isDefined<T>(value: T | null | undefined): value is T;
 export declare function capitalize(string: string): string;
@@ -19,14 +17,12 @@ export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
 export declare function camelCaseToUpperSnakeCase(input: string): string;
 export declare function camelCaseToLowerSnakeCase(input: string): string;
-export declare function snakeToLowCamelNode(node: idl.IDLEntry): string;
 export declare function renameDtsToPeer(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameDtsToComponent(fileName: string, language: Language, withFileExtension?: boolean): string;
 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 throwException(message: string): never;
-export declare function entryToFunctionName(_language: Language, declaration: idl.IDLEntry, prefix: string, postfix: string): 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
@@ -48,24 +44,12 @@ export declare class Lazy<T> {
     get value(): T;
 }
 export declare function lazy<T>(factory: () => T): Lazy<T>;
-export declare function isInNamespace(node: idl.IDLEntry): boolean;
 export declare function rightmostIndexOf<T>(array: T[], predicate: (value: T) => boolean): number;
 type StringProperties<T> = {
     [Property in keyof T as (T[Property] extends string ? Property : never)]: T[Property];
 };
 export declare function sorted<T, N extends keyof StringProperties<T>>(array: T[], key: ((value: T) => string) | N): T[];
-export declare function mapLibraryName(node: idl.IDLEntry, lang: Language, mapping?: Map<string, Map<string, string>>, prefix?: string): string;
-export declare function getExtractor(target: idl.IDLInterface, lang: Language, toPtr?: boolean): {
-    receiver?: string;
-    method: string;
-};
-export declare function getInitializerFeature(lang: Language): string;
-export declare function getInitializerDefaultValue(decl: idl.IDLEntry, lang: Language): string;
 export declare function getSyntheticTypesFileName(): 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[];