@idlizer/core 2.1.9-arktscgen-8 → 2.1.10-arktscgen-2

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

@@ -35,17 +35,20 @@ export declare enum IDLEntity {
 }
 export declare enum IDLExtendedAttributes {
     Accessor = "Accessor",
+    Annotations = "Annotations",
     Async = "Async",
     CallSignature = "CallSignature",
     CommonMethod = "CommonMethod",
     Component = "Component",
     ComponentInterface = "ComponentInterface",
+    ComponentModifier = "ComponentModifier",
     Deprecated = "Deprecated",
     Documentation = "Documentation",
     DtsName = "DtsName",
     DtsTag = "DtsTag",
     Entity = "Entity",
     Extends = "Extends",
+    ExtensionMethod = "ExtensionMethod",
     Import = "Import",
     DefaultExport = "DefaultExport",
     IndexSignature = "IndexSignature",
@@ -59,11 +62,14 @@ export declare enum IDLExtendedAttributes {
     Synthetic = "Synthetic",
     Throws = "Throws",
     TraceKey = "TraceKey",
+    TypeAnnotations = "TypeAnnotations",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
     HandWrittenImplementation = "HandWrittenImplementation",
-    ExtraMethod = "ExtraMethod"
+    ExtraMethod = "ExtraMethod",
+    OverloadAlias = "OverloadAlias",
+    OverloadPriority = "OverloadPriority"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -72,6 +78,9 @@ export declare enum IDLAccessorAttribute {
 export interface IDLExtendedAttribute {
     name: string;
     value?: string;
+    typesValue?: IDLType[];
+    nameLocation?: Location;
+    valueLocation?: Location;
 }
 export interface IDLNode {
     _idlNodeBrand: any;
@@ -295,6 +304,9 @@ export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;
     documentation?: string;
+    nodeLocation?: Location;
+    nameLocation?: Location;
+    valueLocation?: Location;
 };
 export declare function createNamespace(name: string, members?: IDLEntry[], nodeInitializer?: IDLNodeInitializer): IDLNamespace;
 export declare function linkParentBack<T extends IDLNode>(node: T): T;

package/build/lib/src/idl.js

@@ -54,17 +54,20 @@ export var IDLEntity;
 export var IDLExtendedAttributes;
 (function (IDLExtendedAttributes) {
     IDLExtendedAttributes["Accessor"] = "Accessor";
+    IDLExtendedAttributes["Annotations"] = "Annotations";
     IDLExtendedAttributes["Async"] = "Async";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
     IDLExtendedAttributes["Component"] = "Component";
     IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
+    IDLExtendedAttributes["ComponentModifier"] = "ComponentModifier";
     IDLExtendedAttributes["Deprecated"] = "Deprecated";
     IDLExtendedAttributes["Documentation"] = "Documentation";
     IDLExtendedAttributes["DtsName"] = "DtsName";
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
     IDLExtendedAttributes["Extends"] = "Extends";
+    IDLExtendedAttributes["ExtensionMethod"] = "ExtensionMethod";
     IDLExtendedAttributes["Import"] = "Import";
     IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
@@ -78,11 +81,14 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TraceKey"] = "TraceKey";
+    IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
+    IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
+    IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 export var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {

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

@@ -58,5 +58,6 @@ 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 { Parser, FatalParserException } from "./from-idl/parser";
 export { D, ConfigTypeInfer, ConfigSchema, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -72,5 +72,6 @@ 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 { Parser, FatalParserException } from "./from-idl/parser";
 export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map

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

@@ -6,7 +6,7 @@ export declare enum LayoutNodeRole {
     COMPONENT = 3,
     SERIALIZER = 4
 }
-export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function';
+export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier';
 export interface LayoutTargetDescription {
     node: IDLEntry;
     role: LayoutNodeRole;

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

@@ -14,7 +14,7 @@ export declare class MaterializedField {
 }
 export declare class MaterializedMethod extends PeerMethod {
     implementationParentName: string;
-    constructor(sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, method: Method);
+    constructor(sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     tsReturnType(): idl.IDLType | undefined;
     getPrivateMethod(): MaterializedMethod;
     withReturnType(returnType: idl.IDLType): MaterializedMethod;

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

@@ -27,8 +27,8 @@ export class MaterializedField {
     }
 }
 export class MaterializedMethod extends PeerMethod {
-    constructor(sig, originalParentName, implementationParentName, returnType, isCallSignature, method) {
-        super(sig, originalParentName, returnType, isCallSignature, method);
+    constructor(sig, originalParentName, implementationParentName, returnType, isCallSignature, uniqueOverloadName, method) {
+        super(sig, originalParentName, returnType, isCallSignature, uniqueOverloadName, method);
         this.implementationParentName = implementationParentName;
     }
     tsReturnType() {
@@ -59,7 +59,7 @@ export class MaterializedMethod extends PeerMethod {
 }
 export function copyMaterializedMethod(method, overrides) {
     var _a;
-    return new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
+    return new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, method.uniqueOverloadName, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
 }
 export class MaterializedClass {
     constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctors, // zero size when used for global functions
@@ -97,7 +97,7 @@ export function createDestroyPeerMethod(clazz) {
     if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
-    return new MaterializedMethod(new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
+    return new MaterializedMethod(new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, PeerMethodSignature.DESTROY, new Method(PeerMethodSignature.DESTROY, new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
 export function getInternalClassName(name) {
     return `${name}Internal`;

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

@@ -3,6 +3,10 @@ import { PeerMethod } from "./PeerMethod";
 export interface PeerClassBase {
     generatedName(isCallSignature: boolean): string;
 }
+export interface ComponentBuilderInfo {
+    uniqueOverloadName: string;
+    peerMethodName: string;
+}
 export declare class PeerClass implements PeerClassBase {
     readonly file: IDLFile;
     readonly componentName: string;
@@ -10,6 +14,7 @@ export declare class PeerClass implements PeerClassBase {
     constructor(file: IDLFile, componentName: string, originalFilename: string);
     generatedName(isCallSignature: boolean): string;
     methods: PeerMethod[];
+    componentBuilderInfos: ComponentBuilderInfo[];
     originalClassName: string | undefined;
     originalInterfaceName: string | undefined;
     originalParentName: string | undefined;

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

@@ -21,6 +21,7 @@ export class PeerClass {
         this.componentName = componentName;
         this.originalFilename = originalFilename;
         this.methods = [];
+        this.componentBuilderInfos = [];
         this.originalClassName = undefined;
         this.originalInterfaceName = undefined;
         this.originalParentName = undefined;
@@ -36,6 +37,6 @@ export class PeerClass {
 export function createConstructPeerMethod(clazz) {
     // TODO here is class FQName needed, but can not calculate if from current PeerClass data
     const classFQN = [clazz.componentName];
-    return new PeerMethod(new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
+    return new PeerMethod(new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, PeerMethodSignature.CTOR, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
 }
 //# sourceMappingURL=PeerClass.js.map

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

@@ -10297,6 +10297,7 @@ export declare class PeerLibrary implements LibraryInterface {
     getInteropName(node: idl.IDLNode): string;
     toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
     setFileLayout(strategy: LayoutManagerStrategy): void;
+    withFileLayout(strategy: LayoutManagerStrategy, op: () => void): void;
 }
 export declare const ArkInt32: idl.IDLPrimitiveType;
 export declare const ArkInt64: idl.IDLPrimitiveType;

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, DoubleConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -297,7 +297,7 @@ export class PeerLibrary {
                 case idl.IDLU64Type: return new NumericConvertor(param, type);
                 case idl.IDLF16Type: return new NumericConvertor(param, type);
                 case idl.IDLF32Type: return new NumericConvertor(param, type);
-                case idl.IDLF64Type: return new NumericConvertor(param, type);
+                case idl.IDLF64Type: return new DoubleConvertor(param);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
                 case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
@@ -474,6 +474,12 @@ export class PeerLibrary {
     setFileLayout(strategy) {
         this.layout = new LayoutManager(strategy);
     }
+    withFileLayout(strategy, op) {
+        const old = this.layout;
+        this.layout = new LayoutManager(strategy);
+        op();
+        this.layout = old;
+    }
 }
 export const ArkInt32 = idl.IDLI32Type;
 export const ArkInt64 = idl.IDLI64Type;

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

@@ -8,6 +8,11 @@ export declare class PeerMethodArg {
     readonly type: idl.IDLType;
     constructor(name: string, type: idl.IDLType);
 }
+export type OverloadInfo = {
+    postfix: string;
+    alias?: string;
+    priority?: number;
+};
 export declare class PeerMethodSignature {
     readonly name: string;
     readonly fqname: string;
@@ -16,7 +21,7 @@ export declare class PeerMethodSignature {
     readonly context: idl.IDLEntry | undefined;
     readonly modifiers: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[];
     constructor(name: string, fqname: string, args: PeerMethodArg[], returnType: idl.IDLType, context?: idl.IDLEntry | undefined, modifiers?: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[]);
-    static generateOverloadPostfix(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): string;
+    static mangleOverloadedName(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): OverloadInfo;
     static get CTOR(): string;
     static get GET_FINALIZER(): string;
     static get DESTROY(): string;
@@ -26,8 +31,9 @@ export declare class PeerMethod {
     originalParentName: string;
     returnType: IDLType;
     isCallSignature: boolean;
+    uniqueOverloadName: string;
     method: Method;
-    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, method: Method);
+    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     argConvertors(library: PeerLibrary): ArgConvertor[];
     argAndOutConvertors(library: PeerLibrary): ArgConvertor[];
 }

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

@@ -36,9 +36,15 @@ export class PeerMethodSignature {
         this.context = context;
         this.modifiers = modifiers;
     }
-    static generateOverloadPostfix(decl) {
+    static mangleOverloadedName(decl) {
         if (!decl.parent)
-            return ``;
+            return { postfix: "", };
+        let alias;
+        let forcedPriority;
+        if (idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.OverloadAlias)) {
+            alias = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.OverloadAlias);
+            forcedPriority = Number.parseInt(idl.getExtAttribute(decl, idl.IDLExtendedAttributes.OverloadPriority));
+        }
         let sameNamed = [];
         if (idl.isMethod(decl) || idl.isProperty(decl)) {
             let members = [];
@@ -59,19 +65,31 @@ export class PeerMethodSignature {
         else {
             throw new Error("unexpected type of declaration");
         }
-        return sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+        return sameNamed.length > 1 ? {
+            postfix: sameNamed.indexOf(decl).toString(),
+            alias,
+            priority: forcedPriority !== null && forcedPriority !== void 0 ? forcedPriority : sameNamed.indexOf(decl)
+        } : {
+            postfix: '',
+            alias,
+            priority: forcedPriority,
+        };
     }
     static get CTOR() { return "construct"; }
     static get GET_FINALIZER() { return "getFinalizer"; }
     static get DESTROY() { return "destroyPeer"; }
 }
 export class PeerMethod {
-    constructor(sig, originalParentName, returnType, isCallSignature, method) {
+    constructor(sig, originalParentName, returnType, isCallSignature, 
+    // arkts specific feature, where overloads - are different functions grouped by overload keyword.
+    // Must be moved to interface description as so as `method` field
+    uniqueOverloadName, method) {
         var _a, _b;
         this.sig = sig;
         this.originalParentName = originalParentName;
         this.returnType = returnType;
         this.isCallSignature = isCallSignature;
+        this.uniqueOverloadName = uniqueOverloadName;
         this.method = method;
         // todo remove me
         if ((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.FORCE_CONTEXT))

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

@@ -1,5 +1,6 @@
 import { generatorConfiguration } from "../config";
 import * as idl from "../idl";
+const modulesCache = new Map();
 export function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(idl.getPackageName(nodeOrPackage), module);
@@ -13,14 +14,27 @@ export function getModuleFor(nodeOrPackage) {
     if (typeof nodeOrPackage === "object")
         return getModuleFor(idl.getPackageName(nodeOrPackage));
     const packageName = nodeOrPackage;
+    let module = modulesCache.get(packageName);
+    if (module)
+        return module;
+    module = getApplicableModuleFor(packageName);
+    modulesCache.set(packageName, module);
+    return module;
+}
+function getApplicableModuleFor(packageName) {
     const config = generatorConfiguration();
     const applicableModules = [...config.modules.values()].filter(module => isInModule(packageName, module));
     if (applicableModules.length === 0) {
-        if (nodeOrPackage === '') {
+        if (packageName === '') {
             console.error("WARNING: use current module for empty package");
             return currentModule();
         }
-        throw new Error(`Package ${packageName} is not listed in any module`);
+        if (packageName.startsWith(`idlize.`)) {
+            return currentModule();
+        }
+        const modules = [...config.modules.keys()].map(it => `"${it}"`).join(", ");
+        throw new Error(`Package "${packageName}" is not listed in any module.`
+            + ` Add the "${packageName}" to the existed list of modules [${modules}] or new one in the configuration file`);
     }
     if (applicableModules.length > 1)
         throw new Error(`Package ${packageName} listed in ${applicableModules.length} packages: ${applicableModules.map(it => it.name).join(", ")}`);
@@ -34,9 +48,10 @@ export function currentModule() {
     return result;
 }
 export function isInCurrentModule(nodeOrPackage) {
-    if (typeof nodeOrPackage === 'string')
-        return isInModule(nodeOrPackage, currentModule());
-    else
-        return isInModule(nodeOrPackage, currentModule());
+    // check the nodeOrPackage belongs to some module
+    const module = typeof nodeOrPackage === 'string'
+        ? getModuleFor(nodeOrPackage)
+        : getModuleFor(nodeOrPackage);
+    return generatorConfiguration().moduleName == module.name;
 }
 //# sourceMappingURL=modules.js.map

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

@@ -90,6 +90,7 @@ 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;

package/build/lib/src/util.js

@@ -691,6 +691,11 @@ export function sorted(array, key) {
     return array.map(it => it)
         .sort((a, b) => comparator.compare(a[key], b[key]));
 }
+export function mapLibraryName(node, lang, mapping, prefix = "@") {
+    var _a, _b;
+    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}`;
+}
 function getExtractorClass(target, toPtr = true) {
     if (isInExternalModule(target)) {
         const qualifiedName = idl.getQualifiedName(target, "namespace.name");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.9-arktscgen-8",
+  "version": "2.1.10-arktscgen-2",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -27,18 +27,25 @@
     "webidl2.js/dist/**/*.js",
     "webidl2.js/package.json"
   ],
-  "type": "module",
   "engines": {
     "npm": ">= 8",
     "node": ">= 18"
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.6",
+    "@koalaui/interop": "1.7.9",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },
+  "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"
+  },
   "scripts": {
+    "test": "mocha",
     "clean": "rimraf -g build",
     "compile": "tsc -b ."
   }

package/build/lib/src/LanguageWriters/convertors/KotlinConvertor.d.ts

@@ -1,24 +0,0 @@
-import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
-export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
-    convert(node: idl.IDLNode): string;
-    convertNamespace(node: idl.IDLNamespace): string;
-    convertInterface(node: idl.IDLInterface): string;
-    convertEnum(node: idl.IDLEnum): string;
-    convertTypedef(node: idl.IDLTypedef): string;
-    convertCallback(node: idl.IDLCallback): string;
-    convertMethod(node: idl.IDLMethod): string;
-    convertConstant(node: idl.IDLConstant): string;
-    convertOptional(type: idl.IDLOptionalType): string;
-    convertUnion(type: idl.IDLUnionType): string;
-    convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLImport): string;
-    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
-    convertTypeReference(type: idl.IDLReferenceType): string;
-    convertTypeParameter(type: idl.IDLTypeParameterType): string;
-    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-}
-//# sourceMappingURL=KotlinConvertor.d.ts.map

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

@@ -1,69 +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 { convertNode } from '../nameConvertor';
-export class KotlinTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-    }
-    convert(node) {
-        return convertNode(this, node);
-    }
-    convertNamespace(node) {
-        throw new Error("Not implemented");
-    }
-    convertInterface(node) {
-        throw new Error("Not implemented");
-    }
-    convertEnum(node) {
-        throw new Error("Not implemented");
-    }
-    convertTypedef(node) {
-        throw new Error("Not implemented");
-    }
-    convertCallback(node) {
-        throw new Error("Not implemented");
-    }
-    convertMethod(node) {
-        throw new Error("Not implemented");
-    }
-    convertConstant(node) {
-        throw new Error("Not implemented");
-    }
-    convertOptional(type) {
-        throw new Error("Not implemented");
-    }
-    convertUnion(type) {
-        throw new Error("Not implemented");
-    }
-    convertContainer(type) {
-        throw new Error("Not implemented");
-    }
-    convertImport(type) {
-        throw new Error("Not implemented");
-    }
-    convertTypeReferenceAsImport(type, importClause) {
-        throw new Error("Not implemented");
-    }
-    convertTypeReference(type) {
-        throw new Error("Not implemented");
-    }
-    convertTypeParameter(type) {
-        throw new Error("Not implemented");
-    }
-    convertPrimitiveType(type) {
-        throw new Error("Not implemented");
-    }
-}
-//# sourceMappingURL=KotlinConvertor.js.map

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

@@ -1,4 +0,0 @@
-import * as idl from '../idl';
-import { ReferenceResolver } from './ReferenceResolver';
-export declare function isExternalType(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
-//# sourceMappingURL=isExternalType.d.ts.map

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

@@ -1,15 +0,0 @@
-import * as idl from '../idl';
-import { generatorConfiguration } from '../config';
-export function isExternalType(declaration, resolver) {
-    // declarations outside of the generator input dirs
-    if (generatorConfiguration().externalTypes.get(declaration.name) != undefined)
-        return true;
-    // treat as external types only declarations with methods
-    if (declaration.methods.length == 0)
-        return false;
-    const pack = idl.getPackageName(declaration);
-    if (generatorConfiguration().externalPackages.includes(pack))
-        return true;
-    return false;
-}
-//# sourceMappingURL=isExternalType.js.map