@idlizer/core 2.1.5 → 2.1.7

package/build/lib/src/config.js

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import { D } from "./configDescriber";
+import { capitalize } from "./util";
 const T = {
     stringArray: () => D.array(D.string())
 };
@@ -21,6 +22,9 @@ export const ModuleConfigurationSchema = D.object({
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
 });
+export const HookMethodSchema = D.object({
+    hookName: D.string(),
+});
 export const CoreConfigurationSchema = D.object({
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
@@ -34,6 +38,8 @@ export const CoreConfigurationSchema = D.object({
     forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
+    hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
+    externalModuleTypes: D.map(D.string(), D.string()).onMerge('replace'),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
     globalPackages: T.stringArray()
@@ -51,6 +57,8 @@ export const defaultCoreConfiguration = {
     forceCallback: new Map(),
     forceResource: [],
     forceContext: [],
+    hooks: new Map(),
+    externalModuleTypes: new Map(),
     moduleName: "",
     modules: new Map(),
     globalPackages: []
@@ -69,4 +77,14 @@ export function generatorTypePrefix() {
     const conf = generatorConfiguration();
     return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
+export function generatorHookName(className, methodName) {
+    var _a;
+    const hookMethods = generatorConfiguration().hooks.get(className);
+    if (!hookMethods)
+        return undefined;
+    const hook = hookMethods.get(methodName);
+    if (!hook)
+        return undefined;
+    return (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`;
+}
 //# sourceMappingURL=config.js.map

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

@@ -49,7 +49,7 @@ declare class ValidationBox<T> {
     static fail<T>(errorMessage: string): ValidationBox<T>;
     static ok<T>(value: T): ValidationBox<T>;
     success(): boolean;
-    unwrap(): T;
+    unwrap(message?: string): T;
     error(): string;
     get(): ValidationResult<T>;
     or<U>(x: U): ValidationBox<U | T>;

package/build/lib/src/configDescriber.js

@@ -26,11 +26,11 @@ class ValidationBox {
     success() {
         return this.box.success;
     }
-    unwrap() {
+    unwrap(message) {
         if (this.box.success) {
             return this.box.value;
         }
-        throw new Error("");
+        throw new Error(message !== null && message !== void 0 ? message : 'panic');
     }
     error() {
         if (!this.box.success) {

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName } from "../idl";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
 import { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
@@ -283,6 +283,7 @@ export class CustomPrintVisitor {
                 case IDLNumberType:
                     return "number";
                 case IDLAnyType: return "any";
+                case IDLObjectType: return "Object";
                 case IDLUnknownType: return "unknown";
                 case IDLBufferType: return "ArrayBuffer";
                 case IDLBooleanType: return "boolean";
@@ -355,7 +356,7 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    const [idlFile] = toIDLFile(name, content);
+    const [idlFile] = toIDLFile(name, { content });
     printer.printPackage(idlFile);
     linearizeNamespaceMembers(idlFile.entries).forEach(it => {
         transformMethodsAsync2ReturnPromise(it);

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

@@ -67,7 +67,7 @@ export class IDLLinter {
     }
     enter(node) {
         var _a, _b;
-        if (idl.isInterface(node) || idl.isTypedef(node) || idl.isMethod(node) || idl.isCallable(node)) {
+        if (idl.isInterface(node) || idl.isTypedef(node) || idl.isMethod(node) || idl.isCallable(node) || idl.isCallback(node)) {
             this.context.enter({ typeParameters: new Set((_b = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.map(parseTypeParameter)) !== null && _b !== void 0 ? _b : []) });
             return () => this.context.leave();
         }

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

@@ -4,5 +4,11 @@ export type WebIDLTokenCollection = Record<string, webidl2.Token | null | undefi
 export type IDLTokenInfoMap = Map<unknown, WebIDLTokenCollection>;
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-export declare function toIDLFile(fileName: string, content?: string): [idl.IDLFile, IDLTokenInfoMap];
+type IDLInheritanceMode = 'single' | 'multiple';
+interface ToIDLFileProps {
+    inheritanceMode?: IDLInheritanceMode;
+    content?: string;
+}
+export declare function toIDLFile(fileName: string, { content, inheritanceMode }?: ToIDLFileProps): [idl.IDLFile, IDLTokenInfoMap];
+export {};
 //# sourceMappingURL=deserialize.d.ts.map

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

@@ -33,8 +33,12 @@ export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
 class IDLDeserializer {
-    constructor(info) {
+    enterGenericScope(generics) {
+        this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
+    }
+    constructor(info, inheritanceMode = 'multiple') {
         this.info = info;
+        this.inheritanceMode = inheritanceMode;
         this.namespacePathNames = [];
         this.currentPackage = [];
         this.genericsScopes = [];
@@ -61,7 +65,7 @@ class IDLDeserializer {
     }
     extractGenerics(extAttrs) {
         var _a, _b;
-        return new Set((_b = (_a = this.findExtendedAttribute(extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it)));
+        return (_b = (_a = this.findExtendedAttribute(extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it));
     }
     ///
     toIDLNode(file, node) {
@@ -107,7 +111,6 @@ class IDLDeserializer {
         throw new Error(`unexpected node type: ${toString(node)}`);
     }
     toIDLImport(node) {
-        // console.log(node)
         return this.withInfo(node, idl.createImport(node.clause.split("."), node.alias || undefined));
     }
     interfaceSubkind(node) {
@@ -122,19 +125,38 @@ class IDLDeserializer {
         return idl.IDLInterfaceSubkind.Interface;
     }
     toIDLInterface(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = idl.createInterface(node.name, this.interfaceSubkind(node), (() => {
-            var _a, _b;
-            if (!node.inheritance)
+        this.enterGenericScope(generics);
+        const subkind = this.interfaceSubkind(node);
+        const result = idl.createInterface(node.name, subkind, (() => {
+            if (!node.inheritance) {
                 return [];
-            const parentTypeArgs = this.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 = this.toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
-            return [parentType];
+            }
+            const implementations = [];
+            let extension = undefined;
+            node.inheritance.forEach(it => {
+                var _a;
+                const attributes = it.extAttrs;
+                const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.IDLExtendedAttributes.TypeArguments);
+                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
+                const baseClass = attrs === null || attrs === void 0 ? void 0 : attrs.find(it => it.name === idl.IDLExtendedAttributes.Extends);
+                const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
+                    extendedAttributes: attrs
+                });
+                if (baseClass) {
+                    extension = ref;
+                }
+                else {
+                    implementations.push(ref);
+                }
+            });
+            if (subkind === idl.IDLInterfaceSubkind.Class && extension === undefined && this.inheritanceMode === 'multiple') {
+                extension = idl.IDLTopType;
+            }
+            if (extension) {
+                return [extension, ...implementations];
+            }
+            return implementations;
         })(), node.members
             .filter(isConstructor)
             .map(it => this.toIDLConstructor(file, it)), [], node.members
@@ -145,7 +167,7 @@ class IDLDeserializer {
             .map(it => this.toIDLMethod(file, it, false)), node.members
             .filter(isOperation)
             .filter(it => this.isCallable(it))
-            .map(it => this.toIDLCallable(file, it)), (_a = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+            .map(it => this.toIDLCallable(file, it)), generics, {
             fileName: file,
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -158,7 +180,7 @@ class IDLDeserializer {
         }
         return result;
     }
-    toIDLType(file, type, extAttrs) {
+    toIDLType(file, type, extAttrs, suggestedName) {
         var _a;
         if (typeof type === "string") {
             // is it IDLStringType?
@@ -178,7 +200,7 @@ class IDLDeserializer {
                 types = types.filter(it => it !== idl.IDLUndefinedType);
                 return this.withInfo(type, idl.createOptionalType(collapseTypes(types)));
             }
-            const name = generateSyntheticUnionName(types);
+            const name = suggestedName !== null && suggestedName !== void 0 ? suggestedName : generateSyntheticUnionName(types);
             return this.withInfo(type, idl.createUnionType(types, name));
         }
         if (isSingleTypeDescription(type)) {
@@ -233,12 +255,12 @@ class IDLDeserializer {
         throw new Error(`unexpected type: ${toString(type)}`);
     }
     toIDLCallable(file, node) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (idl.isReferenceType(returnType)) {
             const returnTypeArgs = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
@@ -250,17 +272,17 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
     toIDLMethod(file, node, isFree = false) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (idl.isReferenceType(returnType))
             returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
@@ -272,7 +294,7 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
@@ -287,22 +309,24 @@ class IDLDeserializer {
         }));
     }
     toIDLCallback(file, node) {
+        const generics = this.extractGenerics(node.extAttrs);
+        this.enterGenericScope(generics);
         const result = idl.createCallback(node.name, node.arguments.map(it => this.toIDLParameter(file, it)), this.toIDLType(file, node.idlType, undefined), {
             fileName: file,
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
-        });
+        }, generics);
         if (node.extAttrs.find(it => it.name === "Synthetic")) {
             const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
             addSyntheticType(fqName, result);
         }
+        this.genericsScopes.pop();
         return this.withInfo(node, result);
     }
     toIDLTypedef(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = this.withInfo(node, idl.createTypedef(node.name, this.toIDLType(file, node.idlType, undefined), (_a = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+        this.enterGenericScope(generics);
+        const result = this.withInfo(node, idl.createTypedef(node.name, this.toIDLType(file, node.idlType, undefined, node.name), generics, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
             fileName: file,
@@ -358,7 +382,7 @@ class IDLDeserializer {
             initializer = undefined;
         }
         else {
-            throw new Error(`Not representable enum initializer: ${node.default}`);
+            throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, idl.createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -401,17 +425,39 @@ class IDLDeserializer {
         return node.type === 'import';
     }
     isCallable(node) {
-        return node.extAttrs.some(it => it.name == "Invoke");
+        return node.extAttrs.some(it => it.name == idl.IDLExtendedAttributes.CallSignature);
     }
     ///
+    splitTypeArguments(line) {
+        let buffer = "";
+        let brackets = 0;
+        const result = [];
+        for (const letter of line) {
+            if (letter === ',' && brackets === 0) {
+                result.push(buffer);
+                buffer = '';
+                continue;
+            }
+            if (letter === '<') {
+                brackets += 1;
+            }
+            if (letter === '>') {
+                brackets -= 1;
+            }
+            buffer += letter;
+        }
+        if (buffer.length) {
+            result.push(buffer);
+        }
+        return result;
+    }
     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 = this.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 => { var _a; return this.toIDLType(file, (_a = webidl2.parseType(it, file)) !== null && _a !== void 0 ? _a : it); });
+        return (_a = this.splitTypeArguments(value)) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = webidl2.parseType(it.replaceAll('\'', '"'), file)) !== null && _a !== void 0 ? _a : it); });
     }
     constantValue(node) {
         switch (node.value.type) {
@@ -480,9 +526,9 @@ class IDLDeserializer {
         return attr ? this.toExtendedAttributeValue(attr) : undefined;
     }
 }
-export function toIDLFile(fileName, content) {
+export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
     const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo);
+    const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content)
         content = fs.readFileSync(fileName).toString();
     let packageClause = [];

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

@@ -44,6 +44,7 @@ export declare enum IDLExtendedAttributes {
     DtsName = "DtsName",
     DtsTag = "DtsTag",
     Entity = "Entity",
+    Extends = "Extends",
     Import = "Import",
     DefaultExport = "DefaultExport",
     IndexSignature = "IndexSignature",
@@ -281,7 +282,7 @@ export declare const IDLStringType: IDLPrimitiveType;
 export declare const IDLAnyType: IDLPrimitiveType;
 export declare const IDLUndefinedType: IDLPrimitiveType;
 export declare const IDLUnknownType: IDLPrimitiveType;
-export declare const IDLObjectType: IDLReferenceType;
+export declare const IDLObjectType: IDLPrimitiveType;
 export declare const IDLThisType: IDLPrimitiveType;
 export declare const IDLDate: IDLPrimitiveType;
 export declare const IDLBufferType: IDLPrimitiveType;
@@ -333,13 +334,14 @@ export type IDLCallableInitializer = {
     isAsync: boolean;
     isStatic: boolean;
 };
-export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
+export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
 export declare function createConstructor(parameters: IDLParameter[], returnType: IDLType | undefined, nodeInitializer?: IDLNodeInitializer): IDLConstructor;
 export declare function createCallback(name: string, parameters: IDLParameter[], returnType: IDLType, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallback;
 export declare function createTypeParameterReference(name: string, nodeInitializer?: IDLNodeInitializer): IDLTypeParameterType;
 export declare function createTypedef(name: string, type: IDLType, typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLTypedef;
 export declare function createConstant(name: string, type: IDLType, value: string, nodeInitializer?: IDLNodeInitializer): IDLConstant;
 export declare function clone<T extends IDLNode>(node: T): T;
+export declare function hasTypeParameters(entry: IDLEntry): boolean;
 export declare function escapeIDLKeyword(name: string): string;
 export declare function unescapeKeyword(name: string): string;
 type PrintedIndentInc = "[[indent-inc]]";