@idlizer/core 2.0.15

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

@@ -0,0 +1,28 @@
+import { stringOrNone } from "./util";
+export declare class IndentedPrinter {
+    private output;
+    constructor(output?: string[]);
+    private indent;
+    print(value: stringOrNone): void;
+    pushIndent(level?: number): void;
+    popIndent(level?: number): void;
+    indentDepth(): number;
+    append(printer: IndentedPrinter): void;
+    private indented;
+    getOutput(): string[];
+    printTo(file: string): void;
+    withIndent(prints: (printer: IndentedPrinter) => void): void;
+}
+export declare class IndentedPrinterWithHeader extends IndentedPrinter {
+    header: IndentedPrinter;
+    body: IndentedPrinter;
+    constructor();
+    print(value: stringOrNone): void;
+    printHeader(value: stringOrNone): void;
+    pushIndent(): void;
+    popIndent(): void;
+    pushIndentHeader(): void;
+    popIndentHeader(): void;
+    getOutput(): string[];
+}
+//# sourceMappingURL=IndentedPrinter.d.ts.map

package/build/lib/src/IndentedPrinter.js

@@ -0,0 +1,81 @@
+/*
+* 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 fs from "fs";
+import { indentedBy } from "./util";
+export class IndentedPrinter {
+    constructor(output = []) {
+        this.output = output;
+        this.indent = 0;
+    }
+    print(value) {
+        if (value != undefined)
+            this.output.push(this.indented(value));
+    }
+    pushIndent(level = 1) {
+        this.indent += level;
+    }
+    popIndent(level = 1) {
+        this.indent -= level;
+    }
+    indentDepth() {
+        return this.indent;
+    }
+    append(printer) {
+        this.output = [...this.output, ...printer.output];
+    }
+    indented(input) {
+        return indentedBy(input, this.indent);
+    }
+    getOutput() {
+        return this.output;
+    }
+    printTo(file) {
+        fs.writeFileSync(file, this.getOutput().join("\n"));
+    }
+    withIndent(prints) {
+        this.pushIndent();
+        prints(this);
+        this.popIndent();
+    }
+}
+export class IndentedPrinterWithHeader extends IndentedPrinter {
+    constructor() {
+        super();
+        this.header = new IndentedPrinter();
+        this.body = new IndentedPrinter();
+    }
+    print(value) {
+        this.body.print(value);
+    }
+    printHeader(value) {
+        this.header.print(value);
+    }
+    pushIndent() {
+        this.body.pushIndent();
+    }
+    popIndent() {
+        this.body.popIndent();
+    }
+    pushIndentHeader() {
+        this.header.pushIndent();
+    }
+    popIndentHeader() {
+        this.header.popIndent();
+    }
+    getOutput() {
+        return this.header.getOutput().concat(this.body.getOutput());
+    }
+}
+//# sourceMappingURL=IndentedPrinter.js.map

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

@@ -0,0 +1,15 @@
+export declare class Language {
+    name: string;
+    extension: string;
+    needsUnionDiscrimination: boolean;
+    static TS: Language;
+    static ARKTS: Language;
+    static JAVA: Language;
+    static CPP: Language;
+    static CJ: Language;
+    private constructor();
+    toString(): string;
+    get directory(): string;
+    static fromString(name: string): Language;
+}
+//# sourceMappingURL=Language.d.ts.map

package/build/lib/src/Language.js

@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+export class Language {
+    constructor(name, extension, needsUnionDiscrimination) {
+        this.name = name;
+        this.extension = extension;
+        this.needsUnionDiscrimination = needsUnionDiscrimination;
+    }
+    toString() {
+        return this.name;
+    }
+    get directory() {
+        return this.name.toLowerCase();
+    }
+    static fromString(name) {
+        switch (name) {
+            case "arkts": return Language.ARKTS;
+            case "java": return Language.JAVA;
+            case "ts": return Language.TS;
+            case "cangjie": return Language.CJ;
+            default: throw new Error(`Unsupported language ${name}`);
+        }
+    }
+}
+Language.TS = new Language("TS", ".ts", true);
+Language.ARKTS = new Language("ArkTS", ".ts", true); // using .ts for ArkTS until we get rit of tsc preprocessing
+Language.JAVA = new Language("Java", ".java", false);
+Language.CPP = new Language("C++", ".cc", false);
+Language.CJ = new Language("CangJie", ".cj", false);
+//# sourceMappingURL=Language.js.map

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

@@ -0,0 +1,318 @@
+import * as idl from "../idl";
+import { Language } from "../Language";
+import { LanguageExpression, LanguageStatement, LanguageWriter, ExpressionAssigner } from "./LanguageWriter";
+import { RuntimeType } from "./common";
+import { LibraryInterface } from "../LibraryInterface";
+export interface ArgConvertor {
+    param: string;
+    idlType: idl.IDLType;
+    isScoped: boolean;
+    useArray: boolean;
+    runtimeTypes: RuntimeType[];
+    isOut?: true;
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    interopType(): idl.IDLType;
+    nativeType(): idl.IDLType;
+    targetType(writer: LanguageWriter): string;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    getMembers(): string[];
+    getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
+}
+export declare abstract class BaseArgConvertor implements ArgConvertor {
+    idlType: idl.IDLType;
+    runtimeTypes: RuntimeType[];
+    isScoped: boolean;
+    useArray: boolean;
+    param: string;
+    protected constructor(idlType: idl.IDLType, runtimeTypes: RuntimeType[], isScoped: boolean, useArray: boolean, param: string);
+    nativeType(): idl.IDLType;
+    isPointerType(): boolean;
+    interopType(): idl.IDLType;
+    targetType(writer: LanguageWriter): string;
+    abstract convertorArg(param: string, writer: LanguageWriter): string;
+    abstract convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    abstract convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    getMembers(): string[];
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
+    protected discriminatorFromFields<T>(value: string, writer: LanguageWriter, uniqueFields: T[] | undefined, nameAccessor: (field: T) => string, optionalAccessor: (field: T) => boolean, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class BooleanConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class UndefinedConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class VoidConvertor extends UndefinedConvertor {
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+}
+export declare class StringConvertor extends BaseArgConvertor {
+    private literalValue?;
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    targetType(writer: LanguageWriter): string;
+}
+export declare class EnumConvertor extends BaseArgConvertor {
+    enumEntry: idl.IDLEnum;
+    constructor(param: string, enumEntry: idl.IDLEnum);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    targetType(writer: LanguageWriter): string;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class NumberConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class NumericConvertor extends BaseArgConvertor {
+    private readonly interopNameConvertor;
+    constructor(param: string, type: idl.IDLPrimitiveType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class PointerConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class BufferConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, _: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(_: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class AggregateConvertor extends BaseArgConvertor {
+    protected library: LibraryInterface;
+    protected decl: idl.IDLInterface;
+    protected memberConvertors: ArgConvertor[];
+    members: [string, boolean][];
+    readonly aliasName: string | undefined;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLType, decl: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    protected makeAssigneeExpression(fields: [string, LanguageExpression][], writer: LanguageWriter): LanguageExpression;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    getMembers(): string[];
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class TupleConvertor extends AggregateConvertor {
+    constructor(library: LibraryInterface, param: string, type: idl.IDLType, decl: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    protected makeAssigneeExpression(fields: [string, LanguageExpression][], writer: LanguageWriter): LanguageExpression;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
+}
+export declare class InterfaceConvertor extends BaseArgConvertor {
+    private library;
+    declaration: idl.IDLInterface;
+    constructor(library: LibraryInterface, name: string, param: string, declaration: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    getMembers(): string[];
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class ClassConvertor extends InterfaceConvertor {
+    constructor(library: LibraryInterface, name: string, param: string, declaration: idl.IDLInterface);
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicateMembers: Set<string>): LanguageExpression | undefined;
+}
+export declare class ArrayConvertor extends BaseArgConvertor {
+    private library;
+    private type;
+    private elementType;
+    elementConvertor: ArgConvertor;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLContainerType, elementType: idl.IDLType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
+}
+export declare class MapConvertor extends BaseArgConvertor {
+    private library;
+    keyType: idl.IDLType;
+    valueType: idl.IDLType;
+    keyConvertor: ArgConvertor;
+    valueConvertor: ArgConvertor;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLType, keyType: idl.IDLType, valueType: idl.IDLType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
+}
+export declare class DateConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class ProxyConvertor extends BaseArgConvertor {
+    convertor: ArgConvertor;
+    constructor(convertor: ArgConvertor, suggestedName?: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+    getMembers(): string[];
+}
+export declare class TypeAliasConvertor extends ProxyConvertor {
+    constructor(library: LibraryInterface, param: string, typedef: idl.IDLTypedef);
+}
+export declare class CustomTypeConvertor extends BaseArgConvertor {
+    readonly customTypeName: string;
+    private readonly isGenericType;
+    constructor(param: string, customTypeName: string, isGenericType?: boolean, tsType?: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    /** todo: check */
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class OptionConvertor extends BaseArgConvertor {
+    private library;
+    type: idl.IDLType;
+    private readonly typeConvertor;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorCArg(param: string): string;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
+}
+export declare class UnionConvertor extends BaseArgConvertor {
+    private library;
+    private type;
+    private readonly memberConvertors;
+    private unionChecker;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLUnionType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class FunctionConvertor extends BaseArgConvertor {
+    private library;
+    protected type: idl.IDLReferenceType;
+    constructor(library: LibraryInterface, param: string, type: idl.IDLReferenceType);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class MaterializedClassConvertor extends BaseArgConvertor {
+    declaration: idl.IDLInterface;
+    constructor(param: string, declaration: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class ImportTypeConvertor extends BaseArgConvertor {
+    protected importedName: string;
+    constructor(param: string, importedName: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare class CallbackConvertor extends BaseArgConvertor {
+    private readonly library;
+    private readonly decl;
+    constructor(library: LibraryInterface, param: string, decl: idl.IDLCallback);
+    private get isTransformed();
+    private get transformedDecl();
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter, useSyncVersion?: boolean): LanguageStatement;
+    nativeType(): idl.IDLType;
+    isPointerType(): boolean;
+}
+export declare const CallbackKind = "CallbackKind";
+export declare function generateCallbackKindName(callback: idl.IDLCallback): string;
+export declare function generateCallbackKindAccess(callback: idl.IDLCallback, language: Language): string;
+export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
+export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
+export declare function maybeTransformManagedCallback(callback: idl.IDLCallback): idl.IDLCallback | undefined;
+//# sourceMappingURL=ArgConvertors.d.ts.map