@idlizer/core 2.0.32 → 2.0.33

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

@@ -147,13 +147,14 @@ export declare enum FieldModifier {
 export declare enum MethodModifier {
     PUBLIC = 0,
     PRIVATE = 1,
-    STATIC = 2,
-    NATIVE = 3,
-    INLINE = 4,
-    GETTER = 5,
-    SETTER = 6,
-    PROTECTED = 7,
-    FREE = 8
+    PROTECTED = 2,
+    STATIC = 3,
+    NATIVE = 4,
+    INLINE = 5,
+    GETTER = 6,
+    SETTER = 7,
+    THROWS = 8,
+    FREE = 9
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -214,6 +215,7 @@ export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
     resolver: ReferenceResolver;
     language: Language;
+    protected namespaceStack: string[];
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
     language: Language);
     indentDepth(): number;

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

@@ -309,13 +309,14 @@ export var MethodModifier;
 (function (MethodModifier) {
     MethodModifier[MethodModifier["PUBLIC"] = 0] = "PUBLIC";
     MethodModifier[MethodModifier["PRIVATE"] = 1] = "PRIVATE";
-    MethodModifier[MethodModifier["STATIC"] = 2] = "STATIC";
-    MethodModifier[MethodModifier["NATIVE"] = 3] = "NATIVE";
-    MethodModifier[MethodModifier["INLINE"] = 4] = "INLINE";
-    MethodModifier[MethodModifier["GETTER"] = 5] = "GETTER";
-    MethodModifier[MethodModifier["SETTER"] = 6] = "SETTER";
-    MethodModifier[MethodModifier["PROTECTED"] = 7] = "PROTECTED";
-    MethodModifier[MethodModifier["FREE"] = 8] = "FREE";
+    MethodModifier[MethodModifier["PROTECTED"] = 2] = "PROTECTED";
+    MethodModifier[MethodModifier["STATIC"] = 3] = "STATIC";
+    MethodModifier[MethodModifier["NATIVE"] = 4] = "NATIVE";
+    MethodModifier[MethodModifier["INLINE"] = 5] = "INLINE";
+    MethodModifier[MethodModifier["GETTER"] = 6] = "GETTER";
+    MethodModifier[MethodModifier["SETTER"] = 7] = "SETTER";
+    MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
+    MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -396,6 +397,7 @@ export class LanguageWriter {
         this.printer = printer;
         this.resolver = resolver;
         this.language = language;
+        this.namespaceStack = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
@@ -731,6 +733,7 @@ export class LanguageWriter {
      * Writes closing brace of namespace block and removes one level of indent
      */
     popNamespace(ident = true) {
+        this.namespaceStack.pop();
         if (ident)
             this.popIndent();
         this.print(`}`);

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

@@ -2,7 +2,6 @@ import * as idl from "../../idl";
 import { TSTypeNameConvertor } from "./TSConvertors";
 export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
-    convertEnum(node: idl.IDLEnum): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;

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

@@ -40,13 +40,6 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         return typeName;
     }
-    convertEnum(node) {
-        let ns = idl.getNamespaceName(node).split('.').join('_');
-        if (ns !== '') {
-            ns += '_';
-        }
-        return ns + node.name;
-    }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
             switch (type.elementType[0]) {

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

@@ -25,10 +25,10 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return idl.getFQName(node);
     }
     convertEnum(node) {
-        return node.name;
+        return idl.getFQName(node);
     }
     convertTypedef(node) {
         return node.name;

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

@@ -63,7 +63,8 @@ export class ArkTSEnumEntityStatement {
         this.isExport = isExport;
     }
     write(writer) {
-        const enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        enumName = enumName.split('.').at(-1);
         const members = this.enumEntity.elements
             .flatMap((member, index) => {
             var _a;
@@ -93,7 +94,10 @@ export class ArkTSEnumEntityStatement {
             }
             return res;
         });
+        const nss = idl.getNamespacesPathFor(this.enumEntity);
+        nss.forEach(it => writer.pushNamespace(it.name));
         writer.writeEnum(enumName, members);
+        nss.forEach(() => writer.popNamespace());
     }
 }
 export class ETSLambdaExpression extends LambdaExpression {

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

@@ -124,6 +124,7 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     maybeSemicolon() { return ""; }
     pushNamespace(namespace, ident = true) {
+        this.namespaceStack.push(namespace);
         this.print(`export namespace ${namespace} {`);
         if (ident)
             this.pushIndent();
@@ -133,7 +134,14 @@ export class TSLanguageWriter extends LanguageWriter {
         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);
     }
     getNodeName(type) {
-        return this.typeConvertor.convert(type);
+        // just stub.
+        // language writers and name convertors are subject to rework for namespaces
+        const row = this.typeConvertor.convert(type);
+        const nsPrefix = this.namespaceStack.join('.') + '.';
+        if (row.startsWith(nsPrefix)) {
+            return row.substring(nsPrefix.length);
+        }
+        return row;
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';

package/build/lib/src/from-idl/DtsPrinter.d.ts

@@ -11,7 +11,7 @@ export declare class CustomPrintVisitor {
     printMetadata(node: IDLEnum): void;
     printConstant(node: IDLConstant): void;
     printInterface(node: IDLInterface): void;
-    printMethod(node: IDLMethod | IDLConstructor | IDLCallable, isGlobal?: boolean): void;
+    printMethod(node: IDLMethod | IDLConstructor | IDLCallable, forceAsFree?: boolean): void;
     paramText(paramOrTag: IDLParameter | SignatureTag): string;
     printProperty(node: IDLProperty): void;
     printEnum(node: IDLEnum): void;

package/build/lib/src/from-idl/DtsPrinter.js

@@ -17,6 +17,7 @@ import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, i
 import * as webidl2 from "webidl2";
 import { resolveSyntheticType, toIDLNode } from "./deserialize";
 import { Language } from "../Language";
+import { warn } from "../util";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -136,8 +137,7 @@ export class CustomPrintVisitor {
             this.print("}");
         }
     }
-    // TODO: namespace-related-to-rework: drop 'isGlobal'
-    printMethod(node, isGlobal = false) {
+    printMethod(node, forceAsFree = false) {
         const returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
             ? `: ${this.printTypeForTS(node.returnType, true)}` : "";
         const name = isConstructor(node)
@@ -146,12 +146,14 @@ export class CustomPrintVisitor {
         const typeParams = (node.typeParameters && node.typeParameters.length > 0) ? `<${node.typeParameters.join(",")}>` : "";
         let preamble = "";
         if (!isCallable(node)) {
-            const isStatic = isMethod(node) && node.isStatic && !node.isFree;
+            let isStatic = isMethod(node) && node.isStatic;
             const isProtected = hasExtAttribute(node, IDLExtendedAttributes.Protected);
             const isOptional = isMethod(node) && node.isOptional;
-            const isFree = isMethod(node) && node.isFree;
-            if (isGlobal && !isFree) // TODO: namespace-related-to-rework
-                throw new Error("internal error");
+            let isFree = isMethod(node) && node.isFree;
+            if (forceAsFree) {
+                isStatic = false;
+                isFree = true;
+            }
             const inNamespace = getNamespacesPathFor(node).length > 0;
             preamble = `${isFree ? `${isInNamespace(node) ? "" : "declare "}function ` : ""}${isProtected ? "protected " : ""}${isStatic ? "static " : ""}${name}${isOptional ? "?" : ""}`;
         }
@@ -209,7 +211,8 @@ export class CustomPrintVisitor {
             let definition = this.resolver(createReferenceType(node));
             // TODO: handle namespace case better!
             // TODO: namespace-related-to-rework
-            throw new Error("not implemented yet");
+            //throw new Error("not implemented yet")
+            warn("Typedef-with-Import is not implemented yet");
             // if (definition && !isTypedef(definition) && !hasExtAttribute(definition, IDLExtendedAttributes.Namespace)) {
             //     console.log(`Has better definition for ${node.name}: ${definition.fileName} ${definition.kind}`)
             //     return

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

@@ -59,6 +59,7 @@ export declare enum IDLExtendedAttributes {
     Predefined = "Predefined",
     Protected = "Protected",
     Synthetic = "Synthetic",
+    Throws = "Throws",
     TSType = "TSType",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",

package/build/lib/src/idl.js

@@ -79,6 +79,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
+    IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TSType"] = "TSType";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";

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

@@ -12,6 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { generatorTypePrefix } from "../config";
 import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
 import { capitalize, isDefined } from "../util";
 import { PrimitiveTypesInstance } from "./PrimitiveType";
@@ -69,13 +70,16 @@ export class PeerMethod {
         return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
     }
     generateAPIParameters(converter) {
+        var _a;
         const args = this.argAndOutConvertors.map(it => {
             let isPointer = it.isPointerType();
             return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
         });
         const receiver = this.generateReceiver();
         if (receiver)
-            return [`${receiver.argType} ${receiver.argName}`, ...args];
+            args.unshift(`${receiver.argType} ${receiver.argName}`);
+        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS))
+            args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
         return args;
     }
     generateReceiver() {

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

@@ -53,15 +53,16 @@ export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
         return idl.getFQName(decl);
     }
     convertEnum(decl) {
-        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name).join('_');
-        return `${namespace ? `${namespace}_` : ``}${decl.name}`;
+        return idl.getFQName(decl);
     }
 }
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
-        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name).join('');
-        return `${namespace ? `${namespace}_` : ``}${decl.name}`;
+        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
     }
 }
 ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();

package/package.json

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