@idlizer/core 2.0.15

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

@@ -0,0 +1,384 @@
+/*
+ * 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 webidl2 from "webidl2";
+import * as fs from "fs";
+import { isAttribute, isCallback, isClass, isConstructor, isDictionary, isEnum, isInterface, isOperation, isOptional, isPromiseTypeDescription, isRecordTypeDescription, isSequenceTypeDescription, isSingleTypeDescription, isTypedef, isUnionTypeDescription, isUnspecifiedGenericTypeDescription } from "./webidl2-utils";
+import { toString } from "./toString";
+import * as idl from "../idl";
+import { isDefined, warn } from "../util";
+import { generateSyntheticUnionName } from "../peer-generation/idl/common";
+const syntheticTypes = new Map();
+export function addSyntheticType(name, type) {
+    if (syntheticTypes.has(name))
+        warn(`duplicate synthetic type name "${name}"`); ///throw?
+    syntheticTypes.set(name, type);
+} // check
+export function resolveSyntheticType(type) {
+    return syntheticTypes.get(type.name);
+}
+export function toIDLNode(file, node) {
+    const result = toIDLNodeForward(file, node);
+    idl.linkNamespacesBack(result);
+    return result;
+}
+function toIDLNodeForward(file, node) {
+    if (isEnum(node)) {
+        return toIDLEnum(file, node);
+    }
+    if (isPackage(node)) {
+        return toIDLPackage(node);
+    }
+    if (isImport(node)) {
+        return toIDLImport(node);
+    }
+    if (isClass(node)) {
+        return toIDLInterface(file, node);
+    }
+    if (isInterface(node)) {
+        return toIDLInterface(file, node);
+    }
+    if (isCallback(node)) {
+        return toIDLCallback(file, node);
+    }
+    if (isTypedef(node)) {
+        return toIDLTypedef(file, node);
+    }
+    if (isDictionary(node)) {
+        return toIDLDictionary(file, node);
+    }
+    if (isNamespace(node)) {
+        return toIDLNamespace(file, node);
+    }
+    if (isVersion(node)) {
+        return toIDLVersion(file, node);
+    }
+    if (isAttribute(node)) {
+        return toIDLProperty(file, node);
+    }
+    if (isOperation(node)) {
+        return toIDLMethod(file, node);
+    }
+    throw new Error(`unexpected node type: ${toString(node)}`);
+}
+function isNamespace(node) {
+    return node.type === 'namespace';
+}
+function isVersion(node) {
+    return node.type === 'version';
+}
+function isPackage(node) {
+    return node.type === 'package';
+}
+function isImport(node) {
+    return node.type === 'import';
+}
+function isCallable(node) {
+    return node.extAttrs.some(it => it.name == "Invoke");
+}
+function toIDLPackage(node) {
+    return idl.createPackage(node.nameValue);
+}
+function toIDLImport(node) {
+    // console.log(node)
+    return idl.createImport(node.nameValue);
+}
+function toIDLInterface(file, node) {
+    var _a;
+    const result = idl.createInterface(node.name, isClass(node) ? idl.IDLInterfaceSubkind.Class : idl.IDLInterfaceSubkind.Interface, (() => {
+        var _a, _b;
+        if (!node.inheritance)
+            return [];
+        const parentTypeArgs = extractTypeArguments(file, (_a = node.inheritanceExtAttrs) !== null && _a !== void 0 ? _a : [], idl.IDLExtendedAttributes.TypeArguments);
+        const parentType = idl.createReferenceType(node.inheritance, parentTypeArgs);
+        parentType.fileName = file;
+        if (node.inheritanceExtAttrs)
+            parentType.extendedAttributes = (_b = toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
+        return [parentType];
+    })(), node.members
+        .filter(isConstructor)
+        .map(it => toIDLConstructor(file, it)), [], node.members
+        .filter(isAttribute)
+        .map(it => toIDLProperty(file, it)), node.members
+        .filter(isOperation)
+        .filter(it => !isCallable(it))
+        .map(it => toIDLMethod(file, it)), node.members
+        .filter(isOperation)
+        .filter(it => isCallable(it))
+        .map(it => toIDLCallable(file, it)), (_a = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+        fileName: file,
+        documentation: makeDocs(node),
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+    });
+    if (result.inheritance.length && idl.isReferenceType(result.inheritance[0]))
+        result.inheritance[0].typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
+    if (node.extAttrs.find(it => it.name === "Synthetic"))
+        addSyntheticType(node.name, result);
+    return result;
+}
+function extractTypeArguments(file, extAttrs, attribute) {
+    var _a;
+    const attr = extAttrs === null || extAttrs === void 0 ? void 0 : extAttrs.find(it => it.name === attribute);
+    if (!attr)
+        return undefined;
+    let value = toExtendedAttributeValue(attr);
+    return (_a = value === null || value === void 0 ? void 0 : value.split(",") // TODO need real parsing here. What about "<T, Map<K, Callback<K,R>>, U>"
+    ) === null || _a === void 0 ? void 0 : _a.map(it => toIDLType(file, it));
+}
+function toIDLType(file, type, extAttrs) {
+    var _a;
+    if (typeof type === "string") {
+        // is it IDLStringType?
+        const refType = idl.createReferenceType(type);
+        refType.fileName = file;
+        refType.typeArguments = extractTypeArguments(file, extAttrs, idl.IDLExtendedAttributes.TypeArguments);
+        return refType;
+    }
+    if (type.nullable) {
+        return idl.createOptionalType(toIDLType(file, Object.assign(Object.assign({}, type), { nullable: false }), extAttrs));
+    }
+    if (isUnionTypeDescription(type)) {
+        const types = type.idlType
+            .map(it => toIDLType(file, it))
+            .filter(isDefined);
+        const name = generateSyntheticUnionName(types);
+        return idl.createUnionType(types, name);
+    }
+    if (isSingleTypeDescription(type)) {
+        switch (type.idlType) {
+            case idl.IDLUnknownType.name: return idl.IDLUnknownType;
+            case idl.IDLObjectType.name: return idl.IDLObjectType;
+            case idl.IDLAnyType.name: return idl.IDLAnyType;
+            case idl.IDLBooleanType.name: return idl.IDLBooleanType;
+            case idl.IDLNumberType.name: return idl.IDLNumberType;
+            case idl.IDLStringType.name: return idl.IDLStringType;
+            case idl.IDLUndefinedType.name: return idl.IDLUndefinedType;
+            case idl.IDLVoidType.name: return idl.IDLVoidType;
+            case idl.IDLI8Type.name: return idl.IDLI8Type;
+            case idl.IDLU8Type.name: return idl.IDLU8Type;
+            case idl.IDLI16Type.name: return idl.IDLI16Type;
+            case idl.IDLU16Type.name: return idl.IDLU16Type;
+            case idl.IDLI32Type.name: return idl.IDLI32Type;
+            case idl.IDLU32Type.name: return idl.IDLU32Type;
+            case idl.IDLI64Type.name: return idl.IDLI64Type;
+            case idl.IDLU64Type.name: return idl.IDLU64Type;
+            case idl.IDLF32Type.name: return idl.IDLF32Type;
+            case idl.IDLF64Type.name: return idl.IDLF64Type;
+            case idl.IDLPointerType.name: return idl.IDLPointerType;
+            case idl.IDLBufferType.name: return idl.IDLBufferType;
+        }
+        const combinedExtAttrs = ((_a = type.extAttrs) !== null && _a !== void 0 ? _a : []).concat(extAttrs !== null && extAttrs !== void 0 ? extAttrs : []);
+        const idlRefType = idl.createReferenceType(type.idlType);
+        idlRefType.fileName = file;
+        idlRefType.typeArguments = extractTypeArguments(file, combinedExtAttrs, idl.IDLExtendedAttributes.TypeArguments);
+        idlRefType.extendedAttributes = toExtendedAttributes(combinedExtAttrs);
+        return idlRefType;
+    }
+    if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
+        return idl.createContainerType(type.generic, type.idlType.map(it => toIDLType(file, it)));
+    }
+    if (isUnspecifiedGenericTypeDescription(type)) {
+        return idl.createUnspecifiedGenericType(type.generic, type.idlType.map(it => toIDLType(file, it)));
+    }
+    throw new Error(`unexpected type: ${toString(type)}`);
+}
+function toIDLCallable(file, node) {
+    var _a, _b;
+    if (!node.idlType) {
+        throw new Error(`method with no type ${toString(node)}`);
+    }
+    const returnType = toIDLType(file, node.idlType, node.extAttrs);
+    if (idl.isReferenceType(returnType)) {
+        const returnTypeArgs = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
+        returnType.typeArguments = returnTypeArgs;
+    }
+    return idl.createCallable((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
+        isStatic: node.special === "static",
+        isAsync: node.async,
+    }, {
+        documentation: makeDocs(node),
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+    }, (_b = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
+}
+function toIDLMethod(file, node) {
+    var _a, _b;
+    if (!node.idlType) {
+        throw new Error(`method with no type ${toString(node)}`);
+    }
+    const returnType = toIDLType(file, node.idlType, node.extAttrs);
+    if (idl.isReferenceType(returnType))
+        returnType.typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
+    return idl.createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
+        isStatic: node.special === "static",
+        isAsync: node.async,
+        isOptional: isOptional(node),
+        isFree: false, // TODO: namespace-related-to-rework
+    }, {
+        documentation: makeDocs(node),
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+    }, (_b = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
+}
+function toIDLConstructor(file, node) {
+    return idl.createConstructor(node.arguments.map(it => toIDLParameter(file, it)), undefined, {
+        documentation: makeDocs(node),
+    });
+}
+function toIDLParameter(file, node) {
+    return idl.createParameter(node.name, toIDLType(file, node.idlType, node.extAttrs), node.optional, node.variadic, {
+        fileName: file,
+    });
+}
+function toIDLCallback(file, node) {
+    const result = idl.createCallback(node.name, node.arguments.map(it => toIDLParameter(file, it)), toIDLType(file, node.idlType), {
+        fileName: file,
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+        documentation: makeDocs(node),
+    });
+    if (node.extAttrs.find(it => it.name === "Synthetic"))
+        addSyntheticType(node.name, result);
+    return result;
+}
+function toIDLTypedef(file, node) {
+    var _a;
+    return idl.createTypedef(node.name, toIDLType(file, node.idlType), (_a = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+        documentation: makeDocs(node),
+        fileName: file,
+    });
+}
+function toIDLDictionary(file, node) {
+    const result = idl.createEnum(node.name, [], {
+        documentation: makeDocs(node),
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+        fileName: file,
+    });
+    result.elements = node.members.map(it => toIDLEnumMember(file, it, result));
+    return result;
+}
+function toIDLNamespace(file, node) {
+    const namespace = idl.createNamespace(node.name, toExtendedAttributes(node.extAttrs), file);
+    namespace.members = node.members.map(it => toIDLNodeForward(file, it));
+    return namespace;
+}
+function toIDLVersion(file, node) {
+    return idl.createVersion(node.value, toExtendedAttributes(node.extAttrs), file);
+}
+function toIDLProperty(file, node) {
+    return idl.createProperty(node.name, toIDLType(file, node.idlType), node.readonly, node.special === "static", isOptional(node), {
+        documentation: makeDocs(node),
+        fileName: file,
+        extendedAttributes: toExtendedAttributes(node.extAttrs)
+    });
+}
+function unescapeString(value) {
+    if (!value.length || value[0] !== '"')
+        return value;
+    value = value.slice(1, -1);
+    value = value.replace(/\\((['"\\bfnrtv])|([0-7]{1-3})|x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/g, (_, all, c, oct, h2, u4) => {
+        if (c !== undefined) {
+            switch (c) {
+                case "'": return "'";
+                case '"': return '"';
+                case "\\": return "\\";
+                case "b": return "\b";
+                case "f": return "\f";
+                case "n": return "\n";
+                case "r": return "\r";
+                case "t": return "\t";
+                case "v": return "\v";
+            }
+        }
+        else if (oct !== undefined) {
+            return String.fromCharCode(parseInt(oct, 8));
+        }
+        else if (h2 !== undefined) {
+            return String.fromCharCode(parseInt(h2, 16));
+        }
+        else if (u4 !== undefined) {
+            return String.fromCharCode(parseInt(u4, 16));
+        }
+        throw new Error(`unknown escape sequence: ${_}`);
+    });
+    return value;
+}
+function toIDLEnumMember(file, node, parent) {
+    var _a, _b, _c;
+    let initializer = undefined;
+    if (((_a = node.default) === null || _a === void 0 ? void 0 : _a.type) == "string") {
+        initializer = unescapeString(node.default.value);
+    }
+    else if (((_b = node.default) === null || _b === void 0 ? void 0 : _b.type) == "number") {
+        initializer = +((_c = node.default) === null || _c === void 0 ? void 0 : _c.value);
+    }
+    else if (node.default == null) {
+        initializer = undefined;
+    }
+    else {
+        throw new Error(`Not representable enum initializer: ${node.default}`);
+    }
+    return idl.createEnumMember(node.name, parent, toIDLType(file, node.idlType), initializer, {
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+    });
+}
+function toExtendedAttributes(extAttrs) {
+    return extAttrs.map(it => {
+        return { name: it.name, value: toExtendedAttributeValue(it) };
+    });
+}
+function toExtendedAttributeValue(attr) {
+    var _a, _b;
+    // TODO: be smarter about RHS.
+    if (((_a = attr.rhs) === null || _a === void 0 ? void 0 : _a.value) instanceof Array)
+        return attr.rhs.value.map(v => v.value).join(",");
+    if (typeof ((_b = attr.rhs) === null || _b === void 0 ? void 0 : _b.value) === 'string')
+        return unescapeString(attr.rhs.value);
+    return;
+}
+function makeDocs(node) {
+    let docs = undefined;
+    node.extAttrs.forEach(it => {
+        var _a;
+        if (it.name == "Documentation")
+            docs = (_a = it.rhs) === null || _a === void 0 ? void 0 : _a.value;
+    });
+    return docs;
+}
+function toIDLEnum(file, node) {
+    const result = idl.createEnum(node.name, [], {
+        fileName: file,
+        documentation: makeDocs(node),
+        extendedAttributes: toExtendedAttributes(node.extAttrs),
+    });
+    result.elements = node.values.map((it) => idl.createEnumMember(it.value, result, idl.IDLNumberType, undefined));
+    return result;
+}
+function findExtendedAttribute(extAttrs, name) {
+    const attr = extAttrs.find(it => it.name === name);
+    return attr ? toExtendedAttributeValue(attr) : undefined;
+}
+export function toIDL(file) {
+    const content = fs.readFileSync(file).toString();
+    return webidl2.parse(content).map(it => toIDLNode(file, it));
+}
+export function toIDLFile(fileName) {
+    const content = fs.readFileSync(fileName).toString();
+    const entities = webidl2.parse(content).map(it => toIDLNode(fileName, it));
+    const pack = entities.find(idl.isPackage);
+    return {
+        fileName,
+        entities,
+        package: pack,
+    };
+}
+//# sourceMappingURL=deserialize.js.map

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

@@ -0,0 +1,2 @@
+export declare function toString(node: Object): string;
+//# sourceMappingURL=toString.d.ts.map

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

@@ -0,0 +1,18 @@
+/*
+ * 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 function toString(node) {
+    return JSON.stringify(node, undefined, 4);
+}
+//# sourceMappingURL=toString.js.map

package/build/lib/src/from-idl/webidl2-utils.d.ts

@@ -0,0 +1,20 @@
+import * as webidl2 from "webidl2";
+export declare function isEnum(node: webidl2.IDLRootType): node is webidl2.EnumType;
+export declare function isInterface(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
+export declare function isImport(node: webidl2.IDLRootType): node is webidl2.ImportType;
+export declare function isPackage(node: webidl2.IDLRootType): node is webidl2.PackageType;
+export declare function isClass(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
+export declare function isCallback(node: webidl2.IDLRootType): node is webidl2.CallbackType;
+export declare function isTypedef(node: webidl2.IDLRootType): node is webidl2.TypedefType;
+export declare function isDictionary(node: webidl2.IDLRootType): node is webidl2.DictionaryType;
+export declare function isAttribute(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.AttributeMemberType;
+export declare function isOperation(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.OperationMemberType;
+export declare function isConstructor(node: webidl2.IDLInterfaceMemberType): node is webidl2.ConstructorMemberType;
+export declare function isUnionTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnionTypeDescription;
+export declare function isSingleTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SingleTypeDescription;
+export declare function isSequenceTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SequenceTypeDescription;
+export declare function isPromiseTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.PromiseTypeDescription;
+export declare function isRecordTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.RecordTypeDescription;
+export declare function isUnspecifiedGenericTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnspecifiedGenericTypeDescription;
+export declare function isOptional(node: webidl2.AttributeMemberType | webidl2.OperationMemberType): boolean;
+//# sourceMappingURL=webidl2-utils.d.ts.map

package/build/lib/src/from-idl/webidl2-utils.js

@@ -0,0 +1,84 @@
+/*
+ * 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 { IDLEntity } from "../idl";
+export function isEnum(node) {
+    return node.type === "enum";
+}
+export function isInterface(node) {
+    return node.type === "interface";
+}
+export function isImport(node) {
+    return node.type === "import";
+}
+export function isPackage(node) {
+    return node.type === "package";
+}
+export function isClass(node) {
+    var _a, _b;
+    return isInterface(node)
+        && ((_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value) === IDLEntity.Class;
+}
+export function isCallback(node) {
+    return node.type === "callback";
+}
+export function isTypedef(node) {
+    return node.type === "typedef";
+}
+export function isDictionary(node) {
+    return node.type === "dictionary";
+}
+export function isAttribute(node) {
+    return node.type === "attribute";
+}
+export function isOperation(node) {
+    return node.type === "operation";
+}
+export function isConstructor(node) {
+    return node.type === "constructor";
+}
+export function isUnionTypeDescription(node) {
+    return node.union;
+}
+export function isSingleTypeDescription(node) {
+    return (typeof node.idlType === "string");
+}
+export function isSequenceTypeDescription(node) {
+    return node.generic === "sequence";
+}
+export function isPromiseTypeDescription(node) {
+    return node.generic === "Promise";
+}
+export function isRecordTypeDescription(node) {
+    return node.generic === "record";
+}
+export function isUnspecifiedGenericTypeDescription(node) {
+    switch (node.generic) {
+        case "FrozenArray":
+        case "ObservableArray":
+        case "Promise":
+        case "record":
+        case "sequence":
+        case "":
+            return false;
+    }
+    return true;
+}
+export function isOptional(node) {
+    return node.extAttrs
+        .map((it) => it.name)
+        .map((it) => it.toLowerCase())
+        .includes("optional");
+}
+//# sourceMappingURL=webidl2-utils.js.map