@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idlizer/core",
-    "version": "2.1.10-arktscgen-5",
+    "version": "2.1.10-arktscgen-6",
     "description": "",
     "types": "build/lib/src/index.d.ts",
     "exports": {
@@ -8,13 +8,13 @@
             "./build/lib/src/index.js"
         ],
         "./idl": [
-            "./build/lib/src/idl.js"
+            "./build/lib/src/idl/index.js"
         ]
     },
     "typesVersions": {
         "*": {
             "idl": [
-                "build/lib/src/idl.d.ts"
+                "build/lib/src/idl/index.d.ts"
             ],
             "*": [
                 "build/lib/src/index.d.ts"
@@ -23,9 +23,7 @@
     },
     "files": [
         "build/lib/**/*.js",
-        "build/lib/**/*.d.ts",
-        "webidl2.js/dist/**/*.js",
-        "webidl2.js/package.json"
+        "build/lib/**/*.d.ts"
     ],
     "engines": {
         "npm": ">= 8",
@@ -38,7 +36,8 @@
         "mocha": "^9.2.2",
         "ts-node": "^10.9.2",
         "typescript": "4.9.5",
-        "@types/node": "^18.0.0"
+        "@types/node": "^18.0.0",
+        "rimraf": "^6.0.1"
     },
     "scripts": {
         "test": "mocha",

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

@@ -1,37 +0,0 @@
-import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
-import { InteropArgConvertor } from './InteropConvertors';
-export declare class JavaTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    private resolver;
-    constructor(resolver: ReferenceResolver);
-    protected solidConvertor: import("../../util").Lazy<JavaIdlNodeToSolidStringConvertor>;
-    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;
-    convertOptional(type: idl.IDLOptionalType): string;
-    convertUnion(type: idl.IDLUnionType): string;
-    convertContainer(type: idl.IDLContainerType): string;
-    convertCallback(type: idl.IDLCallback): string;
-    convertMethod(type: idl.IDLMethod): string;
-    convertConstant(type: idl.IDLConstant): 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;
-    private readonly javaPrimitiveToReferenceTypeMap;
-    protected maybeConvertPrimitiveType(javaType: string): string;
-    private mapTypeName;
-}
-declare class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
-    protected solidConvertor: import("../../util").Lazy<this>;
-    convertContainer(type: idl.IDLContainerType): string;
-}
-export declare class JavaInteropArgConvertor extends InteropArgConvertor {
-    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-}
-export {};
-//# sourceMappingURL=JavaConvertors.d.ts.map

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

@@ -1,210 +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 * as idl from '../../idl';
-import { lazy } from '../../util';
-import { convertNode, convertType } from '../nameConvertor';
-import { InteropArgConvertor } from './InteropConvertors';
-function convertJavaOptional(type) {
-    switch (type) {
-        case 'boolean': return 'Opt_Boolean';
-        case 'double': return 'Opt_Number';
-    }
-    return type;
-}
-export class JavaTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.solidConvertor = lazy(() => new JavaIdlNodeToSolidStringConvertor(this.resolver));
-        this.javaPrimitiveToReferenceTypeMap = new Map([
-            ['byte', 'Byte'],
-            ['short', 'Short'],
-            ['int', 'Integer'],
-            ['float', 'Float'],
-            ['double', 'Double'],
-            ['boolean', 'Boolean'],
-            ['char', 'Character'],
-        ]);
-    }
-    convert(node) {
-        const typeString = convertNode(this, node);
-        return this.mapTypeName(typeString);
-    }
-    convertNamespace(node) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertInterface(node) {
-        if (node.subkind === idl.IDLInterfaceSubkind.Tuple) {
-            const javaTypeAliases = node.properties.map(it => convertType(this, idl.maybeOptional(it.type, it.isOptional)));
-            return `Tuple_${javaTypeAliases.join('_')}`;
-        }
-        return node.name;
-    }
-    convertEnum(node) {
-        return node.name;
-    }
-    convertTypedef(node) {
-        return node.name;
-    }
-    convertOptional(type) {
-        return convertJavaOptional(this.convert(type.type));
-    }
-    convertUnion(type) {
-        const aliases = type.types.map(it => convertType(this.solidConvertor.value, it));
-        return `Union_${aliases.join('_')}`;
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const javaType = convertType(this, type.elementType[0]);
-            return `${javaType}[]`;
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            const javaTypes = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
-            return `Map<${javaTypes[0]}, ${javaTypes[1]}>`;
-        }
-        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
-    }
-    convertCallback(type) {
-        return `Callback`;
-    }
-    convertMethod(type) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertConstant(type) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertImport(type) {
-        console.warn("Imports are not implemented yet");
-        return type.name;
-    }
-    convertTypeReferenceAsImport(type, importClause) {
-        return type.name;
-    }
-    convertTypeReference(type) {
-        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
-        if (importAttr) {
-            return this.convertTypeReferenceAsImport(type, importAttr);
-        }
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl) {
-            const declName = this.convert(decl);
-            return declName;
-        }
-        if (type.name === `Optional`) {
-            return convertJavaOptional(idl.printType(type.typeArguments[0]));
-        }
-        return type.name;
-    }
-    convertTypeParameter(type) {
-        // TODO
-        return type.name;
-    }
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLStringType: return 'String';
-            case idl.IDLNumberType: return 'double';
-            case idl.IDLBooleanType: return 'boolean';
-            case idl.IDLUndefinedType: return 'Ark_Undefined';
-            case idl.IDLI8Type: return 'byte';
-            case idl.IDLU8Type: return 'byte';
-            case idl.IDLI16Type: return 'short';
-            case idl.IDLU16Type: return 'short';
-            case idl.IDLI32Type: return 'int';
-            case idl.IDLU32Type: return 'int';
-            case idl.IDLI64Type: return 'long';
-            case idl.IDLU64Type: return 'long';
-            case idl.IDLF32Type: return 'float';
-            case idl.IDLF64Type: return 'double';
-            case idl.IDLPointerType: return 'long';
-            case idl.IDLVoidType: return 'void';
-            case idl.IDLDate: return 'Date';
-            case idl.IDLBufferType: return 'byte[]';
-            case idl.IDLInteropReturnBufferType: return 'byte[]';
-            case idl.IDLSerializerBuffer: return 'long';
-            case idl.IDLAnyType: return 'Ark_Object';
-            case idl.IDLUnknownType: return 'Ark_Object';
-        }
-        throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    maybeConvertPrimitiveType(javaType) {
-        if (this.javaPrimitiveToReferenceTypeMap.has(javaType)) {
-            return this.javaPrimitiveToReferenceTypeMap.get(javaType);
-        }
-        return javaType;
-    }
-    mapTypeName(name) {
-        switch (name) {
-            case 'KPointer': return 'long';
-            case 'KBoolean': return 'boolean';
-            case 'KUInt': return 'int';
-            case 'int32':
-            case 'KInt': return 'int';
-            case 'int64':
-            case 'KLong': return 'long';
-            case 'float32':
-            case 'KFloat': return 'float';
-            case 'float64':
-            case 'KDouble': return 'double';
-            case 'KUint8ArrayPtr': return 'byte[]';
-            case 'KInt32ArrayPtr': return 'int[]';
-            case 'KFloat32ArrayPtr': return 'float[]';
-            // case 'ArrayBuffer': return 'byte[]'
-            case 'KStringPtr': return 'String';
-            case 'string': return 'String';
-        }
-        return name.split(".").at(-1);
-    }
-}
-class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
-    constructor() {
-        super(...arguments);
-        this.solidConvertor = lazy(() => this);
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const javaTypeSolid = convertType(this, type.elementType[0]);
-            return `Array_${javaTypeSolid}`;
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            const javaTypeSolids = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
-            return `Map_${javaTypeSolids[0]}_${javaTypeSolids[1]}`;
-        }
-        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
-    }
-}
-export class JavaInteropArgConvertor extends InteropArgConvertor {
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLNumberType: return "double";
-            case idl.IDLBooleanType: return "boolean";
-            case idl.IDLI64Type: return "long";
-            case idl.IDLU64Type: return "long";
-            case idl.IDLI32Type: return "int";
-            case idl.IDLU32Type: return "int";
-            case idl.IDLF32Type: return "float";
-            case idl.IDLF64Type: return "double";
-            case idl.IDLBigintType: return "long";
-            case idl.IDLSerializerBuffer: return "long";
-            case idl.IDLFunctionType: return "int";
-            case idl.IDLStringType: return "String";
-            case idl.IDLBufferType: return "byte[]";
-            case idl.IDLDate: return "long";
-            case idl.IDLVoidType: return "void";
-            case idl.IDLUndefinedType: return "long";
-            case idl.IDLPointerType: return "long"; // return PrimitiveTypesInstance.NativePointer.getText()
-        }
-        return super.convertPrimitiveType(type);
-    }
-}
-//# sourceMappingURL=JavaConvertors.js.map

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -1,85 +0,0 @@
-import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
-import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
-import * as idl from '../../idl';
-import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
-import { IdlNameConvertor } from "../nameConvertor";
-import { RuntimeType } from "../common";
-import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
-export declare class JavaCastExpression implements LanguageExpression {
-    value: LanguageExpression;
-    type: string;
-    private unsafe;
-    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
-    asString(): string;
-}
-export declare class JavaAssignStatement extends AssignStatement {
-    variableName: string;
-    type: idl.IDLType | undefined;
-    expression: LanguageExpression;
-    isDeclared: boolean;
-    protected isConst: boolean;
-    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
-    write(writer: LanguageWriter): void;
-}
-export declare class JavaLanguageWriter extends CLikeLanguageWriter {
-    protected typeConvertor: IdlNameConvertor;
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor);
-    getNodeName(type: idl.IDLNode): string;
-    fork(options?: {
-        resolver?: ReferenceResolver;
-    }): LanguageWriter;
-    get interopModule(): string;
-    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
-    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
-    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(method: Method): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
-        method: Method;
-        op: () => void;
-    }, setter?: {
-        method: Method;
-        op: () => void;
-    }, initExpr?: LanguageExpression): void;
-    writeTypeDeclaration(decl: idl.IDLTypedef): void;
-    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
-    writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
-    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
-    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeDefinedCheck(value: string): LanguageExpression;
-    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
-    makeMapSize(map: string): LanguageExpression;
-    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
-    makeStatement(expr: LanguageExpression): LanguageStatement;
-    makeUnionSelector(value: string, valueType: string): LanguageStatement;
-    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, _type: string, convertorIndex: number): LanguageExpression;
-    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
-    makeUnionTypeDefaultInitializer(): LanguageExpression;
-    writePrintLog(message: string): void;
-    mapIDLContainerType(type: idl.IDLContainerType): string;
-    applyToObject(p: BaseArgConvertor, param: string, value: string, args?: ObjectArgs): LanguageStatement;
-    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
-    makeUndefined(): LanguageExpression;
-    makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
-    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
-    getTagType(): idl.IDLType;
-    getRuntimeType(): idl.IDLType;
-    makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
-    get supportedModifiers(): MethodModifier[];
-    get supportedFieldModifiers(): FieldModifier[];
-    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
-    makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
-    makeMapInit(type: idl.IDLType): LanguageExpression;
-    makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
-    makeValueFromOption(value: string): LanguageExpression;
-    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
-    castToBoolean(value: string): string;
-}
-//# sourceMappingURL=JavaLanguageWriter.d.ts.map