@idlizer/core 2.0.15

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

@@ -0,0 +1,390 @@
+/*
+ * 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 { Language } from '../../Language';
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { AssignStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { RuntimeType } from "../common";
+import { throwException } from "../../util";
+import { TSKeywords } from '../../languageSpecificKeywords';
+////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+export class TSLambdaExpression extends LambdaExpression {
+    constructor(writer, convertor, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+        this.convertor = convertor;
+    }
+    get statementHasSemicolon() {
+        return false;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => {
+            const maybeOptional = idl.isOptionalType(it) ? "?" : "";
+            return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
+        });
+        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} => { ${this.bodyAsString()} }`;
+    }
+}
+export class TSCastExpression {
+    constructor(value, type, unsafe = false) {
+        this.value = value;
+        this.type = type;
+        this.unsafe = unsafe;
+    }
+    asString() {
+        return this.unsafe
+            ? `unsafeCast<${this.type}>(${this.value.asString()})`
+            : `(${this.value.asString()} as ${this.type})`;
+    }
+}
+class TSUnwrapOptionalExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `(${this.value.asString()})!`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+class TSThrowErrorStatement {
+    constructor(message) {
+        this.message = message;
+    }
+    write(writer) {
+        writer.print(`throw new Error("${this.message}")`);
+    }
+}
+export class TSReturnStatement extends ReturnStatement {
+    constructor(expression) {
+        super(expression);
+        this.expression = expression;
+    }
+}
+class TSLoopStatement {
+    constructor(counter, limit, statement) {
+        this.counter = counter;
+        this.limit = limit;
+        this.statement = statement;
+    }
+    write(writer) {
+        writer.print(`for (let ${this.counter} = 0; ${this.counter} < ${this.limit}; ${this.counter}++) {`);
+        if (this.statement) {
+            writer.pushIndent();
+            this.statement.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+class TSMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`for (const [${this.key}, ${this.value}] of ${this.map}) {`);
+        writer.pushIndent();
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+export class TsTupleAllocStatement {
+    constructor(tuple) {
+        this.tuple = tuple;
+    }
+    write(writer) {
+        writer.writeStatement(writer.makeAssign(this.tuple, undefined, writer.makeString("[]"), false, false));
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class TSLanguageWriter extends LanguageWriter {
+    constructor(printer, resolver, typeConvertor, language = Language.TS) {
+        super(printer, resolver, language);
+        this.typeConvertor = typeConvertor;
+    }
+    maybeSemicolon() { return ""; }
+    pushNamespace(namespace, ident = true) {
+        this.print(`export namespace ${namespace} {`);
+        if (ident)
+            this.pushIndent();
+    }
+    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);
+    }
+    getNodeName(type) {
+        return this.typeConvertor.convert(type);
+    }
+    writeClass(name, op, superClass, interfaces, generics, isDeclared) {
+        let extendsClause = superClass ? ` extends ${superClass}` : '';
+        let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
+        const genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : '';
+        this.printer.print(`export${isDeclared ? " declare" : ""} class ${name}${genericsClause}${extendsClause}${implementsClause} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeInterface(name, op, superInterfaces, isDeclared) {
+        let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
+        this.printer.print(`export ${isDeclared ? "declare " : ""}interface ${name}${extendsClause} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeFunctionDeclaration(name, signature) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    }
+    writeFunctionImplementation(name, signature, op) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+        this.printer.pushIndent();
+        op(this);
+        this.printer.popIndent();
+        this.printer.print('}');
+    }
+    generateFunctionDeclaration(name, signature) {
+        const args = signature.args.map((it, index) => `${signature.argName(index)}${idl.isOptionalType(it) ? '?' : ''}: ${this.getNodeName(it)}`);
+        return `export function ${name}(${args.join(", ")})`;
+    }
+    writeEnum(name, members) {
+        this.printer.print(`export enum ${name} {`);
+        this.printer.pushIndent();
+        for (const [index, member] of members.entries()) {
+            let value;
+            if (member.alias !== undefined) {
+                value = member.alias;
+            }
+            else {
+                value = `${member.stringId != undefined ? `"${member.stringId}"` : `${member.numberId}`}`;
+            }
+            const maybeComma = index < members.length - 1 ? "," : "";
+            this.printer.print(`${member.name} = ${value}${maybeComma}`);
+        }
+        this.printer.popIndent();
+        this.printer.print("}");
+    }
+    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        let prefix = this.makeFieldModifiersList(modifiers);
+        if (prefix)
+            prefix += " ";
+        this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${this.getNodeName(type)}${init}`);
+    }
+    writeNativeMethodDeclaration(name, signature, isNative) {
+        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
+            writer.writeStatement(writer.makeThrowError("Not implemented"));
+        });
+    }
+    writeMethodDeclaration(name, signature, modifiers) {
+        this.writeDeclaration(name, signature, true, false, modifiers);
+    }
+    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+        this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} constructor`, signature, false, true);
+        this.pushIndent();
+        if (superCall) {
+            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
+        }
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeMethodImplementation(method, op) {
+        this.writeDeclaration(method.name, method.signature, true, true, method.modifiers, method.generics);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeProperty(propName, propType) {
+        throw new Error("writeProperty for TS is not implemented yet.");
+    }
+    writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
+        var _a;
+        let prefix = !modifiers ? undefined : this.supportedModifiers
+            .filter(it => modifiers.includes(it))
+            .map(it => this.mapMethodModifier(it)).join(" ");
+        if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER)) {
+            prefix = `get ${prefix}`;
+        }
+        else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) {
+            prefix = `set ${prefix}`;
+            needReturn = false;
+        }
+        else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.FREE)) {
+            prefix = `${needBracket ? "" : "declare "}function ${prefix}`;
+        }
+        prefix = prefix ? prefix.trim() + " " : "";
+        const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
+        // FIXME:
+        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER);
+        const canBeOptional = [];
+        for (let i = signature.args.length - 1; i >= 0; --i) {
+            const prevCanBeOptional = (_a = canBeOptional.at(-1)) !== null && _a !== void 0 ? _a : true;
+            const curr = signature.args[i];
+            const result = prevCanBeOptional && (idl.isOptionalType(curr) || signature.argDefault(i) !== undefined);
+            canBeOptional.push(result);
+        }
+        canBeOptional.reverse();
+        const isOptional = signature.args.map((it, i) => idl.isOptionalType(it) && canBeOptional[i] && !isSetter);
+        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && isOptional[i] ? idl.maybeUnwrapOptionalType(it) : it);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""} ${needBracket ? "{" : ""}`);
+    }
+    makeNull() {
+        return new StringExpression("undefined");
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
+        return new AssignStatement(variableName, type, expr, isDeclared, isConst, options);
+    }
+    makeLambda(signature, body) {
+        return new TSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
+    }
+    makeThrowError(message) {
+        return new TSThrowErrorStatement(message);
+    }
+    makeReturn(expr) {
+        return new TSReturnStatement(expr);
+    }
+    makeCheckOptional(optional, doStatement) {
+        return new CheckOptionalStatement("undefined", optional, doStatement);
+    }
+    makeStatement(expr) {
+        return new ExpressionStatement(expr);
+    }
+    makeLoop(counter, limit, statement) {
+        return new TSLoopStatement(counter, limit, statement);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new TSMapForEachStatement(map, key, value, op);
+    }
+    writePrintLog(message) {
+        this.print(`console.log("${message}")`);
+    }
+    makeCast(value, type, options) {
+        var _a;
+        return new TSCastExpression(value, this.getNodeName(/* FIXME: */ idl.maybeUnwrapOptionalType(type)), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+    typeInstanceOf(type, value, members) {
+        if (idl.isInterface(type)) {
+            if (idl.isInterfaceSubkind(type)) {
+                if (!members) {
+                    throw new Error("Members must be defined for interface type recognition!");
+                }
+                return this.makeString(members.map(it => `${value}.hasOwnProperty("${it}")`).join("&&"));
+            }
+            if (idl.isClassSubkind(type)) {
+                return super.typeInstanceOf(type, value, members);
+            }
+        }
+        throw new Error(`typeInstanceOf fails: not class or interface: ${this.getNodeName(type)}`);
+    }
+    getObjectAccessor(convertor, value, args) {
+        if (convertor.useArray && (args === null || args === void 0 ? void 0 : args.index) != undefined) {
+            return `${value}[${args.index}]`;
+        }
+        return `${value}`;
+    }
+    makeUndefined() {
+        return this.makeString("undefined");
+    }
+    makeRuntimeType(rt) {
+        return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
+    }
+    makeTupleAlloc(option) {
+        return new TsTupleAllocStatement(option);
+    }
+    makeArrayInit(type, size) {
+        var _a;
+        return this.makeString(`new Array<${this.getNodeName(type.elementType[0])}>(${(_a = size === null || size === void 0 ? void 0 : size.toString()) !== null && _a !== void 0 ? _a : ''})`);
+    }
+    makeClassInit(type, paramenters) {
+        return this.makeString(`new ${this.getNodeName(type)}(${paramenters.map(it => it.asString()).join(", ")})`);
+    }
+    makeMapInit(type) {
+        return this.makeString(`new ${this.getNodeName(type)}()`);
+    }
+    makeMapInsert(keyAccessor, key, valueAccessor, value) {
+        // keyAccessor and valueAccessor are equal in TS
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+    }
+    makeUnwrapOptional(expression) {
+        return new TSUnwrapOptionalExpression(expression);
+    }
+    getTagType() {
+        return idl.createReferenceType("Tags");
+    }
+    getRuntimeType() {
+        return idl.IDLI32Type;
+    }
+    makeTupleAssign(receiver, fields) {
+        return this.makeAssign(receiver, undefined, this.makeString(`[${fields.map(it => `${it}!`).join(",")}]`), false);
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC];
+    }
+    get supportedFieldModifiers() {
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
+    }
+    enumFromOrdinal(value, enumEntry) {
+        return this.makeString(`Object.values(${idl.forceAsNamedNode(enumEntry).name})[${value.asString()}]`);
+    }
+    ordinalFromEnum(value, enumEntry) {
+        const enumName = idl.forceAsNamedNode(enumEntry).name;
+        const decl = idl.isReferenceType(enumEntry) ? this.resolver.resolveTypeReference(enumEntry) : undefined;
+        if (decl && idl.isEnum(decl) && idl.isStringEnum(decl)) {
+            return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
+        }
+        return value;
+    }
+    makeEnumCast(enumName, unsafe, convertor) {
+        if (unsafe) {
+            return this.makeUnsafeCast(convertor, enumName);
+        }
+        return enumName;
+    }
+    castToBoolean(value) { return `+${value}`; }
+    makeCallIsObject(value) {
+        return this.makeString(`${value} instanceof Object`);
+    }
+    escapeKeyword(keyword) {
+        return TSKeywords.has(keyword) ? keyword + "_" : keyword;
+    }
+    makeDiscriminatorConvertor(convertor, value, index) {
+        const decl = this.resolver.resolveTypeReference(idl.createReferenceType(this.getNodeName(convertor.nativeType()), undefined, convertor.idlType));
+        if (decl === undefined || !idl.isEnum(decl)) {
+            throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
+        }
+        const ordinal = idl.isStringEnum(decl)
+            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), idl.createReferenceType(this.getNodeName(convertor.nativeType()), undefined, convertor.idlType))
+            : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(idl.IDLI32Type), convertor, index);
+        const { low, high } = idl.extremumOfOrdinals(decl);
+        return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [
+            this.makeNaryOp(">=", [ordinal, this.makeString(low.toString())]),
+            this.makeNaryOp("<=", [ordinal, this.makeString(high.toString())])
+        ]);
+    }
+    makeSerializerConstructorSignature() {
+        return new NamedMethodSignature(idl.IDLVoidType, [], []);
+    }
+}
+//# sourceMappingURL=TsLanguageWriter.js.map

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

@@ -0,0 +1,21 @@
+import * as idl from "./idl";
+import { Language } from "./Language";
+import { ArgConvertor } from "./LanguageWriters/ArgConvertors";
+import { ReferenceResolver } from "./peer-generation/ReferenceResolver";
+export interface LibraryFileInterface {
+    get entries(): idl.IDLEntry[];
+}
+export interface LibraryInterface extends ReferenceResolver {
+    language: Language;
+    get files(): LibraryFileInterface[];
+    typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
+    declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
+    getInteropName(node: idl.IDLNode): string;
+    createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
+    getCurrentContext(): string | undefined;
+    /**
+     * todo: is it really needed?
+     */
+    libraryPrefix: string;
+}
+//# sourceMappingURL=LibraryInterface.d.ts.map

package/build/lib/src/LibraryInterface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LibraryInterface.js.map

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

@@ -0,0 +1,8 @@
+export interface GeneratorConfiguration {
+    param<T>(name: string): T;
+    paramArray<T>(name: string): T[];
+}
+export declare function setDefaultConfiguration(config: GeneratorConfiguration): void;
+export declare function generatorConfiguration(): GeneratorConfiguration;
+export declare function generatorTypePrefix(): string;
+//# sourceMappingURL=config.d.ts.map

package/build/lib/src/config.js

@@ -0,0 +1,20 @@
+class EmptyGeneratorConfiguration {
+    param(name) {
+        throw new Error(`${name} is unknown`);
+    }
+    paramArray(name) {
+        throw new Error(`array ${name} is unknown`);
+    }
+}
+let currentConfig = new EmptyGeneratorConfiguration();
+export function setDefaultConfiguration(config) {
+    currentConfig = config;
+}
+export function generatorConfiguration() {
+    return currentConfig;
+}
+export function generatorTypePrefix() {
+    const conf = generatorConfiguration();
+    return `${conf.param("TypePrefix")}${conf.param("LibraryPrefix")}`;
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,35 @@
+import { stringOrNone } from "../util";
+import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLImport, IDLPackage, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
+import { Language } from "../Language";
+export declare class CustomPrintVisitor {
+    private resolver;
+    private language;
+    output: string[];
+    constructor(resolver: (type: IDLReferenceType) => IDLEntry | undefined, language: Language);
+    currentInterface?: IDLInterface;
+    visit(node: IDLEntry, wrapNamespaces?: boolean): void;
+    printMetadata(node: IDLEnum): void;
+    printConstant(node: IDLConstant): void;
+    printInterface(node: IDLInterface): void;
+    printMethod(node: IDLMethod | IDLConstructor | IDLCallable, isGlobal?: boolean): void;
+    paramText(paramOrTag: IDLParameter | SignatureTag): string;
+    printProperty(node: IDLProperty): void;
+    printEnum(node: IDLEnum): void;
+    printTypedef(node: IDLTypedef | IDLCallback): void;
+    printVersion(node: IDLVersion): void;
+    printNamespace(node: IDLNamespace): void;
+    printImport(node: IDLImport): void;
+    printPackage(node: IDLPackage): void;
+    checkVerbatim(node: IDLEntry): void;
+    private indent;
+    indented(input: string): string;
+    pushIndent(): void;
+    popIndent(): void;
+    print(value: stringOrNone): void;
+    private printTypeForTS;
+    private toTypeName;
+    private callback;
+    private literal;
+}
+export declare function idlToDtsString(name: string, content: string): string;
+//# sourceMappingURL=DtsPrinter.d.ts.map