@idlizer/core 2.0.15

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

@@ -0,0 +1,375 @@
+/*
+ * 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 { indentedBy } from "../util";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isPackage, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor } from "../idl";
+import * as webidl2 from "webidl2";
+import { resolveSyntheticType, toIDLNode } from "./deserialize";
+import { Language } from "../Language";
+export class CustomPrintVisitor {
+    constructor(resolver, language) {
+        this.resolver = resolver;
+        this.language = language;
+        this.output = [];
+        this.indent = 0;
+    }
+    visit(node, wrapNamespaces = false) {
+        const namespacesPath = wrapNamespaces ? getNamespacesPathFor(node) : [];
+        for (const namespace of namespacesPath) {
+            this.print(`${namespace.namespace ? "" : "declare "}namespace ${namespace.name} {`);
+            this.pushIndent();
+        }
+        if (hasExtAttribute(node, IDLExtendedAttributes.TSType) && this.language == Language.TS)
+            return;
+        if (isInterface(node)) {
+            this.printInterface(node);
+        }
+        else if (isMethod(node) || isConstructor(node) || isCallable(node)) {
+            this.printMethod(node);
+        }
+        else if (isPackage(node)) {
+            this.printPackage(node);
+        }
+        else if (isImport(node)) {
+            this.printImport(node);
+        }
+        else if (isProperty(node)) {
+            this.printProperty(node);
+        }
+        else if (isTypedef(node)) {
+            this.printTypedef(node);
+        }
+        else if (isEnum(node)) {
+            this.printEnum(node);
+        }
+        else if (isCallback(node)) {
+            this.printTypedef(node);
+        }
+        else if (isVersion(node)) {
+            this.printVersion(node);
+        }
+        else if (isNamespace(node)) {
+            this.printNamespace(node);
+        }
+        else {
+            throw new Error(`Unexpected node kind: ${IDLKind[node.kind]}`);
+        }
+        for (const namespace of namespacesPath) {
+            this.popIndent();
+            this.print("}");
+        }
+    }
+    printMetadata(node) {
+        var _a, _b;
+        const imports = (_a = node.elements
+            .find(it => it.name === "imports")) === null || _a === void 0 ? void 0 : _a.initializer;
+        if (imports)
+            this.print(imports);
+        const exports = (_b = node.elements
+            .find(it => it.name === "exports")) === null || _b === void 0 ? void 0 : _b.initializer;
+        if (exports)
+            this.print(exports);
+    }
+    printConstant(node) {
+        this.print(`${node.namespace ? "" : "declare "}const ${node.name} : ${isPrimitiveType(node.type) ? "" : "typeof"} ${this.printTypeForTS(node.type)} = ${node.value}`);
+    }
+    printInterface(node) {
+        var _a;
+        let typeSpec = this.toTypeName(node);
+        // Workaround for an SDK declaration clash between `WrappedBuilder` and `ContentModifier`
+        if (node.name === "WrappedBuilder")
+            typeSpec = "WrappedBuilder<Args extends any[]>";
+        const entity = (_a = getExtAttribute(node, IDLExtendedAttributes.Entity)) !== null && _a !== void 0 ? _a : IDLEntity.Interface;
+        if (entity === IDLEntity.Literal) {
+            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, false, true)}`);
+        }
+        else if (entity === IDLEntity.Tuple) {
+            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, false)}`);
+        }
+        else if (entity === IDLEntity.NamedTuple) {
+            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
+        }
+        else {
+            // restore globalScope
+            if (hasExtAttribute(node, IDLExtendedAttributes.GlobalScope)) {
+                node.methods.map(it => this.visit(it, true));
+                node.constants.map(it => this.visit(it, true));
+                return;
+            }
+            let interfaces = node.inheritance;
+            let keyword = "extends";
+            if (node.subkind === IDLInterfaceSubkind.Class) {
+                const superType = getSuperType(node);
+                if (superType)
+                    typeSpec += ` extends ${this.printTypeForTS(superType)}`;
+                interfaces = interfaces.slice(1);
+                keyword = "implements";
+            }
+            if (interfaces.length > 0)
+                typeSpec += ` ${keyword} ${interfaces.map(it => this.toTypeName(it)).join(", ")}`;
+            this.print(`${node.namespace ? "" : "declare "}${entity.toLowerCase()} ${typeSpec} {`);
+            this.currentInterface = node;
+            this.pushIndent();
+            node.constructors.map(it => this.visit(it));
+            node.properties.map(it => this.visit(it));
+            node.methods.map(it => this.visit(it));
+            node.callables.map(it => this.visit(it));
+            let verbatim = getVerbatimDts(node);
+            if (verbatim) {
+                verbatim
+                    .split("\n")
+                    .map(it => this.print(it));
+            }
+            this.popIndent();
+            this.print("}");
+        }
+    }
+    // TODO: namespace-related-to-rework: drop 'isGlobal'
+    printMethod(node, isGlobal = false) {
+        const returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
+            ? `: ${this.printTypeForTS(node.returnType, true)}` : "";
+        const name = isConstructor(node)
+            ? this.currentInterface.subkind === IDLInterfaceSubkind.Class ? "constructor" : "new"
+            : getName(node);
+        const typeParams = (node.typeParameters && node.typeParameters.length > 0) ? `<${node.typeParameters.join(",")}>` : "";
+        let preamble = "";
+        if (!isCallable(node)) {
+            const isStatic = isMethod(node) && node.isStatic && !node.isFree;
+            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");
+            preamble = `${isFree ? `${node.namespace ? "" : "declare "}function ` : ""}${isProtected ? "protected " : ""}${isStatic ? "static " : ""}${name}${isOptional ? "?" : ""}`;
+        }
+        this.print(`${preamble}${typeParams}(${mixMethodParametersAndTags(node).map(p => this.paramText(p)).join(", ")})${returnType};`);
+    }
+    paramText(paramOrTag) {
+        const param = paramOrTag;
+        if (param.kind === IDLKind.Parameter)
+            return `${param.isVariadic ? "..." : ""}${getName(param)}${param.isOptional ? "?" : ""}: ${this.printTypeForTS(param.type)}`;
+        const tag = paramOrTag;
+        return `${tag.name}: ${tag.value}`;
+    }
+    printProperty(node) {
+        var _a;
+        const isCommonMethod = hasExtAttribute(node, IDLExtendedAttributes.CommonMethod);
+        let isProtected = hasExtAttribute(node, IDLExtendedAttributes.Protected);
+        if (isCommonMethod) {
+            // TODO: not very clean, but we don't need to print these so far.
+            // if (PeerGeneratorConfig.ignorePeerMethod.includes(node.name)) return
+            const typeParams = (_a = this.currentInterface) === null || _a === void 0 ? void 0 : _a.typeParameters;
+            const returnType = typeParams && typeParams.length > 0 ? typeParams[0] : this.currentInterface.name;
+            this.print(`${getName(node)}(value: ${this.printTypeForTS(node.type, undefined, undefined, isCommonMethod)}): ${returnType};`);
+        }
+        else if (hasExtAttribute(node, IDLExtendedAttributes.Accessor)) {
+            const accessorName = getExtAttribute(node, IDLExtendedAttributes.Accessor);
+            if (accessorName == IDLAccessorAttribute.Getter) {
+                this.print(`get ${getName(node)}(): ${this.printTypeForTS(node.type)};`);
+            }
+            else if (accessorName == IDLAccessorAttribute.Setter) {
+                this.print(`set ${getName(node)}(value: ${this.printTypeForTS(node.type)});`);
+            }
+        }
+        else {
+            this.print(`${isProtected ? "protected " : ""}${node.isStatic ? "static " : ""}${node.isReadonly ? "readonly " : ""}${getName(node)}${node.isOptional ? "?" : ""}: ${this.printTypeForTS(node.type)};`);
+        }
+    }
+    printEnum(node) {
+        this.print(`${node.namespace ? "" : "declare "}enum ${node.name} {`);
+        this.pushIndent();
+        node.elements.forEach(it => {
+            const initializer = (it.type === IDLStringType ? `"${it.initializer}"` : `${it.initializer}`);
+            this.print(`${getName(it)} = ${initializer},`);
+            let originalName = getExtAttribute(it, IDLExtendedAttributes.OriginalEnumMemberName);
+            if (originalName && originalName != getName(it)) {
+                this.print(`${originalName} = ${initializer},`);
+            }
+        });
+        this.popIndent();
+        this.print("}");
+    }
+    printTypedef(node) {
+        // Let's skip imported declarations
+        if (isTypedef(node) &&
+            hasExtAttribute(node, IDLExtendedAttributes.Import)) {
+            let definition = this.resolver(createReferenceType(node.name, undefined, node));
+            // TODO: handle namespace case better!
+            // TODO: namespace-related-to-rework
+            throw new Error("not implemented yet");
+            // if (definition && !isTypedef(definition) && !hasExtAttribute(definition, IDLExtendedAttributes.Namespace)) {
+            //     console.log(`Has better definition for ${node.name}: ${definition.fileName} ${definition.kind}`)
+            //     return
+            // }
+        }
+        const text = isCallback(node) ? this.callback(node)
+            : hasExtAttribute(node, IDLExtendedAttributes.Import) ? IDLAnyType.name
+                : this.printTypeForTS(node.type);
+        const typeParams = node.typeParameters && node.typeParameters.length > 0 ? `<${node.typeParameters.join(",")}>` : "";
+        this.print(`${node.namespace ? '' : 'declare '}type ${getName(node)}${typeParams} = ${text};`);
+    }
+    printVersion(node) {
+        let text = node.value.join(".");
+        this.print(`// version ${text}`);
+    }
+    printNamespace(node) {
+        let verbatimDts = getVerbatimDts(node);
+        if (verbatimDts) {
+            this.print(verbatimDts);
+            return;
+        }
+        this.print(`${node.namespace ? "" : "declare "} namespace ${node.name} {`);
+        this.pushIndent();
+        node.members.forEach(member => this.visit(member));
+        this.popIndent();
+        this.print("}");
+    }
+    printImport(node) {
+        this.print(`// import ${node.name}`);
+    }
+    printPackage(node) {
+        this.print(`// package ${node.name}`);
+    }
+    checkVerbatim(node) {
+        let verbatim = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
+        if (verbatim) {
+            verbatim
+                .substring(1, verbatim.length - 2)
+                .split('\n')
+                .forEach(it => this.print(it));
+        }
+    }
+    indented(input) {
+        return indentedBy(input, this.indent);
+    }
+    pushIndent() {
+        this.indent++;
+    }
+    popIndent() {
+        this.indent--;
+    }
+    print(value) {
+        if (value)
+            this.output.push(this.indented(value));
+    }
+    printTypeForTS(type, undefinedToVoid, sequenceToArrayInterface = false, isCommonMethod = false) {
+        if (!type)
+            throw new Error("Missing type");
+        if (isOptionalType(type))
+            return `${this.printTypeForTS(type.type, undefinedToVoid, sequenceToArrayInterface)} | undefined`;
+        if (isPrimitiveType(type)) {
+            switch (type) {
+                case IDLU8Type:
+                case IDLI8Type:
+                case IDLU16Type:
+                case IDLI16Type:
+                case IDLU32Type:
+                case IDLI32Type:
+                case IDLU64Type:
+                case IDLI64Type:
+                case IDLF16Type:
+                case IDLF32Type:
+                case IDLF64Type:
+                case IDLNumberType:
+                    return "number";
+                case IDLAnyType: return "any";
+                case IDLUnknownType: return "unknown";
+                case IDLBufferType: return "ArrayBuffer";
+                case IDLBooleanType: return "boolean";
+                case IDLUndefinedType: return undefinedToVoid ? "void" : "undefined";
+                case IDLStringType: return "string";
+                case IDLVoidType: return "void";
+                case IDLThisType: return "T";
+                case IDLPointerType: return "number|bigint";
+                default: throw new Error(`Unknown primitive type ${DebugUtils.debugPrintType(type)}`);
+            }
+        }
+        if (isContainerType(type)) {
+            if (!sequenceToArrayInterface && IDLContainerUtils.isSequence(type))
+                return `${type.elementType.map(it => this.printTypeForTS(it)).join(",")}[]`;
+            return `${mapContainerType(type)}<${type.elementType.map(it => this.printTypeForTS(it)).join(",")}>`;
+        }
+        if (isUnspecifiedGenericType(type))
+            return `${type.name}<${type.typeArguments.map(it => this.printTypeForTS(it)).join(",")}>`;
+        if (isReferenceType(type))
+            return this.toTypeName(type);
+        if (isUnionType(type))
+            return `(${type.types.map(it => this.printTypeForTS(it)).join("|")})`;
+        if (isTypeParameterType(type))
+            return type.name;
+        throw new Error(`Cannot map type: ${IDLKind[type.kind]}`);
+    }
+    toTypeName(node) {
+        var _a, _b;
+        if (isReferenceType(node)) {
+            const synthDecl = this.resolver(node);
+            if (synthDecl && isSyntheticEntry(synthDecl)) {
+                if (isInterface(synthDecl)) {
+                    const isTuple = getExtAttribute(synthDecl, IDLExtendedAttributes.Entity) === IDLEntity.Tuple;
+                    return this.literal(synthDecl, isTuple, !isTuple);
+                }
+                if (isCallback(synthDecl)) {
+                    return this.callback(synthDecl);
+                }
+            }
+        }
+        if (hasExtAttribute(node, IDLExtendedAttributes.Import)) {
+            return IDLAnyType.name;
+        }
+        let typeSpec = isNamedNode(node) ? node.name : "MISSING_TYPE_NAME";
+        if ((isInterface(node) || isCallback(node) || isTypedef(node)) && ((_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.length))
+            typeSpec = `${typeSpec}<${(_b = node.typeParameters) === null || _b === void 0 ? void 0 : _b.join(",")}>`;
+        if (isReferenceType(node) && node.typeArguments)
+            typeSpec = `${typeSpec}<${node.typeArguments.map(it => this.toTypeName(it))}>`;
+        return typeSpec;
+    }
+    callback(node) {
+        return `((${node.parameters.map(p => this.paramText(p)).join(", ")}) => ${this.printTypeForTS(node.returnType)})`;
+    }
+    literal(node, isTuple, includeFieldNames) {
+        return `${isTuple ? "[" : "{"} ${node.properties.map(it => {
+            const questionMark = it.isOptional ? "?" : "";
+            const type = this.printTypeForTS(it.type);
+            return includeFieldNames ? `${getName(it)}${questionMark}: ${type}` : `${type}${questionMark}`;
+        }).join(", ")} ${isTuple ? "]" : "}"}`;
+    }
+}
+export function idlToDtsString(name, content) {
+    let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
+    webidl2.parse(content)
+        .filter(it => !!it.type)
+        .map(it => toIDLNode(name, it))
+        .forEach(it => {
+        transformMethodsAsync2ReturnPromise(it);
+        printer.visit(it);
+    });
+    return printer.output.join("\n");
+}
+function mapContainerType(idlType) {
+    if (IDLContainerUtils.isSequence(idlType)) {
+        return "Array";
+    }
+    if (IDLContainerUtils.isRecord(idlType)) {
+        return "Map";
+    }
+    if (IDLContainerUtils.isPromise(idlType)) {
+        return "Promise";
+    }
+    throw new Error(`Unmapped container type: ${DebugUtils.debugPrintType(idlType)}`);
+}
+function getName(node) {
+    var _a;
+    return escapeIDLKeyword((_a = getExtAttribute(node, IDLExtendedAttributes.DtsName)) !== null && _a !== void 0 ? _a : node.name);
+}
+//# sourceMappingURL=DtsPrinter.js.map

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

@@ -0,0 +1,5 @@
+import { IDLEntry } from "../idl";
+export declare function fromIDL(inputDir: string, inputFile: string | undefined, outputDir: string, extension: string, verbose: boolean, transform: (name: string, content: string) => string): void;
+export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLEntry[][];
+export declare const licence = "/*\n * Copyright (c) 2024 Huawei Device Co., Ltd.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n";
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1,83 @@
+/*
+ * 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 * as path from "path";
+import * as webidl2 from "webidl2";
+import { toIDLNode } from "./deserialize";
+import { zip } from "../util";
+function getFilesRecursive(dirPath, arrayOfFiles = []) {
+    let files = fs.readdirSync(dirPath);
+    arrayOfFiles = arrayOfFiles || [];
+    files.forEach((file) => {
+        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getFilesRecursive(dirPath + "/" + file, arrayOfFiles);
+        }
+        else {
+            arrayOfFiles.push(path.join(dirPath, file));
+        }
+    });
+    return arrayOfFiles;
+}
+export function fromIDL(inputDir, inputFile, outputDir, extension, verbose, transform) {
+    inputDir = path.resolve(inputDir);
+    const files = inputFile
+        ? [path.join(inputDir, inputFile)]
+        : getFilesRecursive(inputDir);
+    const results = files
+        .map((file) => transform(file, fs.readFileSync(file).toString()));
+    zip(files, results)
+        .forEach(([fileName, output]) => {
+        fs.mkdirSync(outputDir, { recursive: true });
+        console.log('producing', path.relative(inputDir, fileName));
+        const outFile = path.join(outputDir, path.relative(inputDir, fileName).replace(".idl", extension));
+        if (verbose)
+            console.log(output);
+        if (!fs.existsSync(path.dirname(outFile))) {
+            fs.mkdirSync(path.dirname(outFile), { recursive: true });
+        }
+        fs.writeFileSync(outFile, licence.concat(output));
+        console.log("saved", outFile);
+    });
+}
+export function scanIDL(inputDir, inputFile) {
+    inputDir = path.resolve(inputDir);
+    const files = inputFile
+        ? [path.join(inputDir, inputFile)]
+        : fs.readdirSync(inputDir)
+            .map((elem) => path.join(inputDir, elem));
+    return files
+        .map((file) => {
+        let content = fs.readFileSync(file).toString();
+        let parsed = webidl2.parse(content);
+        return parsed.filter(it => !!it.type).map(it => toIDLNode(file, it));
+    });
+}
+export const licence = `/*
+ * 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.
+ */
+
+`;
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1,9 @@
+import * as webidl2 from "webidl2";
+import * as idl from "../idl";
+import * as lib from "../library";
+export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
+export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
+export declare function toIDLNode(file: string, node: webidl2.IDLRootType): idl.IDLEntry;
+export declare function toIDL(file: string): idl.IDLEntry[];
+export declare function toIDLFile(fileName: string): lib.IDLFile;
+//# sourceMappingURL=deserialize.d.ts.map