@idlizer/arktscgen 2.1.9-arktscgen-8 → 2.1.9-arktscgen-9

package/lib/index.js

@@ -3825,6 +3825,7 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
     IDLExtendedAttributes["Extends"] = "Extends";
+    IDLExtendedAttributes["ExtensionMethod"] = "ExtensionMethod";
     IDLExtendedAttributes["Import"] = "Import";
     IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
@@ -4890,6 +4891,7 @@ function linearizeNamespaceMembers(entries) {
     return linearized;
 }
 
+const modulesCache = new Map();
 function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(getPackageName(nodeOrPackage), module);
@@ -4903,14 +4905,27 @@ function getModuleFor(nodeOrPackage) {
     if (typeof nodeOrPackage === "object")
         return getModuleFor(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(", ")}`);
@@ -4924,10 +4939,11 @@ function currentModule() {
     return result;
 }
 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;
 }
 
 /*
@@ -5091,13 +5107,14 @@ class ExpressionStatement {
     }
 }
 class BlockStatement {
-    constructor(statements, inScope = true) {
+    constructor(statements, inScope = true, newLine = true) {
         this.statements = statements;
         this.inScope = inScope;
+        this.newLine = newLine;
     }
     write(writer) {
         if (this.inScope) {
-            writer.print("{");
+            this.newLine ? writer.print("{") : writer.printer.appendLastString(" {");
             writer.pushIndent();
         }
         this.statements.forEach(s => s.write(writer));
@@ -5123,7 +5140,12 @@ class IfStatement {
             }
         });
         if (this.elseStatement !== undefined) {
-            writer.print("else");
+            if ((this.thenStatement instanceof BlockStatement) && this.thenStatement.inScope) {
+                writer.printer.appendLastString(" else");
+            }
+            else {
+                writer.print("else");
+            }
             this.writeBody(writer, this.elseStatement, () => {
                 if (this.insideElseOp) {
                     this.insideElseOp();
@@ -5154,7 +5176,7 @@ class MultiBranchIfStatement {
                 writer.print(`if (${expr.asString()}) {`);
             }
             else {
-                writer.print(`else if (${expr.asString()}) {`);
+                writer.printer.appendLastString(` else if (${expr.asString()}) {`);
             }
             writer.pushIndent();
             stmt.write(writer);
@@ -5162,7 +5184,7 @@ class MultiBranchIfStatement {
             writer.print("}");
         });
         if (this.statements.length > 0 && this.elseStatement !== undefined) {
-            writer.print("else {");
+            writer.printer.appendLastString(" else {");
             writer.pushIndent();
             this.elseStatement.write(writer);
             writer.popIndent();
@@ -5216,21 +5238,17 @@ class LambdaExpression {
         this.resolver = resolver;
         this.body = body;
     }
-    bodyAsString() {
-        var _a;
+    bodyAsString(isScoped = false) {
         const writer = this.originalWriter.fork();
         if (this.body) {
-            for (const stmt of this.body) {
-                stmt.write(writer);
-            }
+            writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
         writer.features.forEach(([feature, module]) => {
             this.originalWriter.addFeature(feature, module);
         });
-        return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
-            .filter(line => line !== "")
-            .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
-            .join("\n"));
+        return writer.getOutput()
+            .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
+            .join("\n");
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -5665,9 +5683,9 @@ LanguageWriter._isReferenceRelativeToNamespaces = false;
 * limitations under the License.
 */
 class IndentedPrinter {
-    constructor(output = []) {
+    constructor(output = [], indent = 0) {
         this.output = output;
-        this.indent = 0;
+        this.indent = indent;
     }
     print(value) {
         if (value != undefined)
@@ -5685,6 +5703,13 @@ class IndentedPrinter {
     append(printer) {
         this.output = [...this.output, ...printer.output];
     }
+    appendLastString(value) {
+        if (value != undefined) {
+            let last = this.output.pop();
+            last = last ? last.concat(value) : value;
+            this.output.push(last);
+        }
+    }
     indented(input) {
         return indentedBy(input, this.indent);
     }
@@ -6603,7 +6628,7 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
         if (e.name == "WebIDLParseError") {
             let tokens = e.tokens;
             let range = tokens.length > 0 ? rangeForToken(offsets, tokens[0]) : undefined;
-            ParsingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName, range: range }], e.bareMessage);
+            ParsingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage);
         }
         UnknownErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_c = e.message) !== null && _c !== void 0 ? _c : "");
     }
@@ -6922,18 +6947,18 @@ class CppMapResizeStatement {
     }
 }
 class CppMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (int32_t i = 0; i < ${this.map}.size; i++) {`);
         writer.pushIndent();
         writer.print(`auto ${this.key} = ${this.map}.keys[i];`);
         writer.print(`auto ${this.value} = ${this.map}.values[i];`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -6978,7 +7003,7 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
+        return new CppLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
     writeDeclaration(name, signature, modifiers, postfix) {
         const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
@@ -7119,8 +7144,8 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new CppMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new CppMapForEachStatement(map, key, value, body);
     }
     makeArrayInit(type) {
         return this.makeString(`{}`);
@@ -7315,7 +7340,7 @@ class TSLambdaExpression extends LambdaExpression {
             const maybeOptional = isOptionalType(it) ? "?" : "";
             return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
         });
-        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} => { ${this.bodyAsString()} }`;
+        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} =>${this.bodyAsString(true)}`;
     }
 }
 class TSCastExpression {
@@ -7372,16 +7397,16 @@ class TSLoopStatement {
     }
 }
 class TSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const [${this.key}, ${this.value}] of ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -7412,7 +7437,7 @@ class TSLanguageWriter extends LanguageWriter {
     }
     fork(options) {
         var _a;
-        return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
+        return new TSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
         // another stub. Bad one.
@@ -7595,8 +7620,8 @@ class TSLanguageWriter extends LanguageWriter {
     makeLoop(counter, limit, statement) {
         return new TSLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new TSMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new TSMapForEachStatement(map, key, value, body);
     }
     writePrintLog(message) {
         this.print(`console.log("${message}")`);
@@ -7812,6 +7837,23 @@ function createDeclarationNameConvertor(language) {
  * limitations under the License.
  */
 ////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+class ETSStringExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    changeQuotes(value) {
+        return `'${value.substring(1, value.length - 1)}'`;
+    }
+    asString() {
+        if (this.value.startsWith('"') && this.value.endsWith('"')) {
+            return this.changeQuotes(this.value);
+        }
+        return this.value;
+    }
+}
+////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
 class EtsAssignStatement {
@@ -7839,18 +7881,18 @@ class EtsAssignStatement {
     }
 }
 class ArkTSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const pair of ${this.map}) {`);
         writer.pushIndent();
         writer.print(`const ${this.key} = pair[0]`);
         writer.print(`const ${this.value} = pair[1]`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -7916,7 +7958,7 @@ class ETSLambdaExpression extends LambdaExpression {
             isRetTypeCallback = resolved !== undefined && isCallback$1(resolved);
         }
         return `(${params.join(", ")})${isRetTypeCallback
-            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} => { ${this.bodyAsString()} }`;
+            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} =>${this.bodyAsString(true)}`;
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -7946,7 +7988,7 @@ class ETSLanguageWriter extends TSLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
+        return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
         return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst, options);
@@ -7954,8 +7996,11 @@ class ETSLanguageWriter extends TSLanguageWriter {
     makeLambda(signature, body) {
         return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
     }
-    makeMapForEach(map, key, value, op) {
-        return new ArkTSMapForEachStatement(map, key, value, op);
+    makeString(value) {
+        return new ETSStringExpression(value);
+    }
+    makeMapForEach(map, key, value, body) {
+        return new ArkTSMapForEachStatement(map, key, value, body);
     }
     makeMapSize(map) {
         return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?
@@ -8184,12 +8229,16 @@ class AggregateConvertor extends BaseArgConvertor {
         throw new Error("Do not use for aggregates");
     }
     convertorSerialize(param, value, printer) {
-        this.memberConvertors.forEach((it, index) => {
-            let memberName = this.members[index][0];
-            let memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
-            printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
-            it.convertorSerialize(param, `${value}_${memberName}`, printer);
+        const stmts = this.memberConvertors.flatMap((it, index) => {
+            const memberName = this.members[index][0];
+            const memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
+            const memberMangledName = `${value}${capitalize(memberName)}`;
+            return [
+                printer.makeAssign(memberMangledName, undefined, printer.makeString(memberAccess), true),
+                it.convertorSerialize(param, memberMangledName, printer)
+            ];
         });
+        return printer.makeBlock(stmts, false);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
@@ -8204,7 +8253,8 @@ class AggregateConvertor extends BaseArgConvertor {
         for (let i = 0; i < this.decl.properties.length; i++) {
             const prop = this.decl.properties[i];
             const propConvertor = this.memberConvertors[i];
-            statements.push(propConvertor.convertorDeserialize(`${bufferName}_${prop.name}_buf`, deserializerName, (expr) => {
+            const propName = `${bufferName}${capitalize(prop.name)}`;
+            statements.push(propConvertor.convertorDeserialize(`${propName}TempBuf`, deserializerName, (expr) => {
                 if (writer.language === Language.CPP) {
                     // prefix initialization for CPP, just easier. Waiting for easy work with nullables
                     return writer.makeAssign(`${bufferName}.${writer.escapeKeyword(prop.name)}`, undefined, expr, false);
@@ -8213,7 +8263,7 @@ class AggregateConvertor extends BaseArgConvertor {
                  * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
                  */
                 const memberType = maybeOptional(prop.type, prop.isOptional);
-                return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
+                return writer.makeAssign(propName, memberType, expr, true, true);
             }, writer));
         }
         if (writer.language === Language.CPP) {
@@ -8231,7 +8281,7 @@ class AggregateConvertor extends BaseArgConvertor {
         }
         else {
             const resultExpression = this.makeAssigneeExpression(this.decl.properties.map(prop => {
-                return [prop.name, writer.makeString(`${bufferName}_${prop.name}`)];
+                return [prop.name, writer.makeString(`${bufferName}${capitalize(prop.name)}`)];
             }), writer);
             statements.push(assigneer(resultExpression));
         }
@@ -8267,10 +8317,10 @@ class InterfaceConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         throw new Error("Must never be used");
     }
-    convertorSerialize(param, value, printer) {
+    convertorSerialize(param, value, writer) {
         const accessor = getSerializerName(this.declaration);
-        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        printer.writeStaticMethodCall(accessor, 'write', [`${param}Serializer`, value]);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessor = getSerializerName(this.declaration);
@@ -8311,7 +8361,7 @@ class CustomTypeConvertor extends BaseArgConvertor {
     }
     /** todo: check */
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `writeCustomObject`, [`"${this.customTypeName}"`, printer.makeCastCustomObject(value, this.isGenericType).asString()]);
+        return printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `writeCustomObject`, [printer.makeString(`"${this.customTypeName}"`), printer.makeCastCustomObject(value, this.isGenericType)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const type = writer.language === Language.CPP
@@ -8336,13 +8386,13 @@ class FunctionConvertor extends BaseArgConvertor {
         this.library = library;
     }
     convertorArg(param, writer) {
-        return writer.language == Language.CPP ? `makeArkFunctionFromId(${param})` : `registerCallback(${param})`;
+        throw new Error('Shall not be used');
     }
     convertorSerialize(param, value, writer) {
-        writer.writeMethodCall(`${param}Serializer`, "writeFunction", [value]);
+        throw new Error('Shall not be used');
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), IDLFunctionType, { optional: true }));
+        throw new Error('Shall not be used');
     }
     nativeType() {
         return IDLFunctionType;
@@ -8379,7 +8429,7 @@ class MaterializedClassConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         const accessorRoot = getSerializerName(this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        printer.writeStaticMethodCall(accessorRoot, 'write', [`${param}Serializer`, value]);
+        return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessorRoot = getSerializerName(this.declaration);
@@ -8951,10 +9001,9 @@ D.object({
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
     hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
-    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
-    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
+    libraryNameMapping: D.maybe(D.map(D.string(), D.map(D.string(), D.string())).onMerge('replace')),
     globalPackages: T.stringArray()
 });
 const defaultCoreConfiguration = {
@@ -8972,10 +9021,9 @@ const defaultCoreConfiguration = {
     forceResource: [],
     forceContext: [],
     hooks: new Map(),
-    externalTypes: new Map(),
-    externalPackages: [],
     moduleName: "",
     modules: new Map(),
+    libraryNameMapping: new Map(),
     globalPackages: []
 };
 let currentConfig = defaultCoreConfiguration;
@@ -11169,6 +11217,10 @@ function nodeType(node) {
     var _a, _b;
     return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === Config.nodeTypeAttribute)) === null || _b === void 0 ? void 0 : _b.value;
 }
+function nativeType(node) {
+    var _a, _b;
+    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === 'c_type')) === null || _b === void 0 ? void 0 : _b.value;
+}
 function nodeNamespace(node) {
     var _a;
     return (_a = getNamespacesPathFor(node)[0]) === null || _a === void 0 ? void 0 : _a.name;
@@ -11283,6 +11335,16 @@ class Typechecker {
         declaration.inheritance.forEach(parent => {
             isHeir || (isHeir = this.isHeir(parent.name, ancestor));
         });
+        // TODO: Should be fixed or moved to config
+        const objects = [
+            "Program", "ArkTsConfig", "AstDumper", "SrcDumper",
+            "FunctionSignature", "ValidationInfo"
+        ];
+        if (!isHeir) {
+            if (ancestor === Config.defaultAncestor &&
+                objects.includes(declaration.name))
+                return true;
+        }
         return isHeir;
     }
     isPeer(node) {
@@ -11294,11 +11356,6 @@ class Typechecker {
             return true;
         if (this.isHeir(node, Config.defaultAncestor))
             return true;
-        // TODO: fix
-        if (node === "Program")
-            return true;
-        if (node === "ArkTsConfig")
-            return true;
         return false;
     }
     isReferenceTo(type, isTarget) {
@@ -12390,13 +12447,13 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
             string: (type) => wrap(PeersConstructions.receiveString),
             reference: (type) => this.typechecker.isHeir(type.name, Config.astNodeCommonAncestor)
                 ? wrap(PeersConstructions.unpackNonNullable)
-                : wrap(type.name),
+                : wrap(baseNameString(type.name)),
             optional: (type) => {
                 if (isReferenceType(type.type)) {
                     if (this.typechecker.isHeir(type.type.name, Config.astNodeCommonAncestor)) {
                         return wrap(PeersConstructions.unpackNullable);
                     }
-                    return wrap(PeersConstructions.newOf(type.type.name));
+                    return wrap(PeersConstructions.newOf(baseNameString(type.type.name)));
                 }
                 throwException(`unexpected optional of non-reference type`);
             },
@@ -12453,7 +12510,7 @@ class PeerPrinter extends SingleFilePrinter {
         });
     }
     printPeer() {
-        this.writer.writeClass(this.node.name, () => this.printBody(), this.parent ? this.importer.withPeerImport(this.parent) : undefined);
+        this.writer.writeClass(this.node.name, () => this.printBody(), this.parent ? this.importer.withPeerImport(baseNameString(this.parent)) : undefined);
     }
     printBody() {
         this.printConstructor();
@@ -12487,7 +12544,9 @@ class PeerPrinter extends SingleFilePrinter {
     printMethods() {
         this.node.methods.forEach(it => {
             if (isCreateOrUpdate(it.name)) {
-                if (isAbstract(this.node)) {
+                // TODO: This condition is not clear - classes with c_type attribute
+                // is not abstract too, is it?
+                if (isAbstract(this.node) && nativeType(this.node) === undefined) {
                     return;
                 }
                 return this.printCreateOrUpdate(it);
@@ -12859,12 +12918,12 @@ class BaseInterfaceFilterTransformer extends Transformer {
         this.typechecker = new Typechecker(this.file.entries);
     }
     transformInterface(entry) {
-        if (this.shouldFilterOutInterface(entry.name)) {
+        if (this.shouldFilterOutInterface(entry)) {
             return undefined;
         }
         return createUpdatedInterface(entry, entry.methods
             .filter(it => !this.shouldFilterOutMethod(entry.name, it.name))
-            .filter(it => !this.isReferringForbiddenOrMissing(it, (name) => this.shouldFilterOutInterface(name))), entry.name, entry.inheritance, entry.extendedAttributes, entry.properties
+            .filter(it => !this.isReferringForbiddenOrMissing(it, (iface) => this.shouldFilterOutInterface(iface))), entry.name, entry.inheritance, entry.extendedAttributes, entry.properties
             .filter(it => !this.shouldFilterOutProperty(entry.name, it.name)));
     }
     isReferringForbiddenOrMissing(node, predicate) {
@@ -12874,10 +12933,8 @@ class BaseInterfaceFilterTransformer extends Transformer {
             .map(innerTypeIfContainer)
             .filter(it => {
             if (isReferenceType(it)) {
-                if (this.typechecker.isReferenceTo(it, isInterface$1) && predicate(it.name)) {
-                    return true;
-                }
-                if (this.typechecker.findRealDeclaration(it.name) === undefined) {
+                const decl = this.typechecker.findRealDeclaration(it.name);
+                if (!decl || isInterface$1(decl) && predicate(decl)) {
                     return true;
                 }
             }
@@ -12905,8 +12962,10 @@ class OptionsFilterTransformer extends BaseInterfaceFilterTransformer {
         super(file);
         this.config = config;
     }
-    shouldFilterOutInterface(name) {
-        return this.config.ignore.isIgnoredInterface(name);
+    shouldFilterOutInterface(entry) {
+        var _a;
+        const ns = (_a = nodeNamespace(entry)) !== null && _a !== void 0 ? _a : '';
+        return this.config.ignore.isIgnoredInterface(entry.name, ns);
     }
     shouldFilterOutMethod(node, name) {
         return this.config.ignore.isIgnoredMethod(node, name);
@@ -13126,17 +13185,12 @@ class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
     constructor(idl) {
         super(idl, true);
     }
-    shouldFilterOutInterface(name) {
-        if (this.typechecker.isHeir(name, Config.astNodeCommonAncestor))
-            return false;
-        if (this.typechecker.isHeir(name, Config.defaultAncestor))
-            return false;
-        // TODO: fix
-        if (name === "Program")
+    shouldFilterOutInterface(node) {
+        if (this.typechecker.isHeir(node.name, Config.astNodeCommonAncestor))
             return false;
-        if (name === "ArkTsConfig")
+        if (this.typechecker.isHeir(node.name, Config.defaultAncestor))
             return false;
-        console.log(`FILTERED (AST) ${name}`);
+        console.log(`FILTERED (AST) ${node.name}`);
         return true;
     }
     shouldFilterOutMethod(node, name) {
@@ -13514,14 +13568,24 @@ class DynamicEmitter {
 class IgnoreOptions {
     constructor(filePath) {
         var _a, _b;
-        this.full = [];
         this.partial = [];
+        this.ignored = new Map();
         if (filePath === undefined) {
             return;
         }
         const ignore = lib.parse(fs__namespace$1.readFileSync(filePath).toString()).ignore;
-        this.full = (_a = ignore === null || ignore === void 0 ? void 0 : ignore.full) !== null && _a !== void 0 ? _a : [];
-        this.partial = (_b = ignore === null || ignore === void 0 ? void 0 : ignore.partial) !== null && _b !== void 0 ? _b : [];
+        this.partial = (_a = ignore === null || ignore === void 0 ? void 0 : ignore.partial) !== null && _a !== void 0 ? _a : [];
+        const full = (_b = ignore === null || ignore === void 0 ? void 0 : ignore.full) !== null && _b !== void 0 ? _b : [];
+        full.forEach((fqName) => {
+            const parts = fqName.split('.');
+            const [ns, name] = parts.length === 1 ? ['', parts.at(0)] : parts;
+            if (!this.ignored.has(ns)) {
+                this.ignored.set(ns, new Map());
+            }
+            const last = name.at(-1);
+            const key = last === '-' || last === '+' ? name.slice(0, -1) : name;
+            this.ignored.get(ns).set(key, last !== '+');
+        });
     }
     isIgnoredMethod(iface, method) {
         var _a;
@@ -13531,8 +13595,9 @@ class IgnoreOptions {
         var _a;
         return (_a = this.partial) === null || _a === void 0 ? void 0 : _a.some(it => { var _a; return it.interface === iface && ((_a = it.properties) === null || _a === void 0 ? void 0 : _a.includes(name)); });
     }
-    isIgnoredInterface(name) {
-        return this.full.includes(name);
+    isIgnoredInterface(name, ns = '') {
+        var _a, _b;
+        return (_b = (_a = this.ignored.get(ns)) === null || _a === void 0 ? void 0 : _a.get(name)) !== null && _b !== void 0 ? _b : false;
     }
 }
 // TODO: remove when interfaces fixed!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/arktscgen",
-  "version": "2.1.9-arktscgen-8",
+  "version": "2.1.9-arktscgen-9",
   "description": "",
   "main": "lib/index.js",
   "bin": "lib/index.js",
@@ -19,7 +19,7 @@
   "license": "Apache-2.0",
   "keywords": [],
   "dependencies": {
-    "@idlizer/core": "2.1.9-arktscgen-8",
+    "@idlizer/core": "2.1.9-arktscgen-9",
     "@types/node": "^18.0.0",
     "commander": "^10.0.0",
     "typescript": "^4.9.5"