@idlizer/core 2.1.2 → 2.1.7

package/build/lib/src/resolveNamedNode.js

@@ -0,0 +1,105 @@
+/*
+ * 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 { isReferenceType, hasExtAttribute, IDLExtendedAttributes } from "./idl";
+import { isFile, isNamedNode, isNamespace, isEnum, isInterface, isImport } from "./idl";
+export function resolveNamedNode(target, pov, corpus) {
+    let result;
+    let povScope = [];
+    while (pov) {
+        if (isFile(pov)) {
+            if (result = resolveDownFromFile(target, pov, corpus))
+                return result;
+            const importUsings = pov.entries.filter(it => isImport(it) && !it.name).map(it => it);
+            for (const importUsing of importUsings)
+                if (result = resolveDownFromRoot([...importUsing.clause, ...target], corpus))
+                    return result;
+            povScope = pov.packageClause.slice();
+            break;
+        }
+        else {
+            if (result = resolveDownFromNode(target, pov, false, corpus))
+                return result;
+        }
+        pov = pov.parent;
+    }
+    for (;;) {
+        if (result = resolveDownFromRoot([...povScope, ...target], corpus))
+            return result;
+        if (povScope.length)
+            povScope.pop();
+        else
+            break;
+    }
+    return undefined;
+}
+function resolveDownFromNode(target, pov, withSelf, corpus) {
+    if (withSelf && isNamedNode(pov)) {
+        if (isReferenceType(pov) || !pov.name.length)
+            return undefined;
+        let nameMatched = target[0] === pov.name;
+        if (!nameMatched)
+            nameMatched = target[0] === "default" && hasExtAttribute(pov, IDLExtendedAttributes.DefaultExport);
+        if (!nameMatched)
+            return undefined;
+        target = target.slice(1);
+        if (isImport(pov)) {
+            return resolveDownFromRoot([...pov.clause, ...target], corpus);
+        }
+        if (!target.length)
+            return pov;
+    }
+    let candidates;
+    if (isNamespace(pov))
+        candidates = pov.members;
+    else if (isEnum(pov))
+        candidates = pov.elements;
+    else if (isInterface(pov))
+        candidates = pov.constants;
+    else
+        return undefined;
+    let result;
+    for (const candidate of candidates) {
+        if (result = resolveDownFromNode(target, candidate, true, corpus))
+            return result;
+    }
+    return undefined;
+}
+function resolveDownFromFile(target, pov, corpus) {
+    let result;
+    for (const candidate of pov.entries) {
+        if (result = resolveDownFromNode(target, candidate, true, corpus))
+            return result;
+    }
+    return undefined;
+}
+function resolveDownFromRoot(target, corpus) {
+    let result;
+    for (const file of corpus) {
+        if (file.packageClause.length >= target.length)
+            continue;
+        let match = true;
+        for (let index = 0; index < file.packageClause.length; ++index)
+            if (file.packageClause[index] !== target[index]) {
+                match = false;
+                break;
+            }
+        if (!match)
+            continue;
+        if (result = resolveDownFromFile(target.slice(file.packageClause.length), file, corpus))
+            return result;
+    }
+    return undefined;
+}
+//# sourceMappingURL=resolveNamedNode.js.map

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

@@ -42,6 +42,7 @@ export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause
 export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
 export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
 export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
+export declare function zipStrip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
 export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
 export declare function identName(node: ts.Node | undefined): string | undefined;
 export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
@@ -53,6 +54,7 @@ export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: bo
 export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
 export declare function camelCaseToUpperSnakeCase(input: string): string;
+export declare function snakeToLowCamelNode(node: idl.IDLEntry): string;
 export declare function renameDtsToPeer(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameDtsToComponent(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameDtsToInterfaces(fileName: string, language: Language, withFileExtension?: boolean): string;
@@ -65,7 +67,7 @@ export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclar
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
  */
-export declare function nameEnumValues(enumTarget: ts.EnumDeclaration): string[];
+export declare function nameEnumValues(enumTarget: string[]): string[];
 export declare function groupBy<K, V>(values: V[], selector: (value: V) => K): Map<K, V[]>;
 export declare function groupByIndexed<K, V>(values: V[], selector: (value: V) => K): Map<K, [V, number][]>;
 export declare function removeExt(filename: string): string;
@@ -84,4 +86,9 @@ export declare class Lazy<T> {
 export declare function lazy<T>(factory: () => T): Lazy<T>;
 export declare function isInNamespace(node: idl.IDLEntry): boolean;
 export declare function rightmostIndexOf<T>(array: T[], predicate: (value: T) => boolean): number;
+type StringProperties<T> = {
+    [Property in keyof T as (T[Property] extends string ? Property : never)]: T[Property];
+};
+export declare function sorted<T, N extends keyof StringProperties<T>>(array: T[], key: ((value: T) => string) | N): T[];
+export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -269,6 +269,13 @@ export function zip(left, right) {
         throw new Error("Arrays of different length");
     return left.map((_, i) => [left[i], right[i]]);
 }
+export function zipStrip(left, right) {
+    const result = [];
+    for (let i = 0; i < left.length && i < right.length; ++i) {
+        result.push([left[i], right[i]]);
+    }
+    return result;
+}
 export function identNameWithNamespace(node, language) {
     let parent = node.parent;
     while (parent && !ts.isModuleDeclaration(parent))
@@ -300,6 +307,9 @@ export function identName(node) {
         return `void`;
     if (node.kind == ts.SyntaxKind.UndefinedKeyword)
         return `undefined`;
+    if (ts.isThisTypeNode(node)) {
+        return 'this';
+    }
     if (ts.isVariableDeclaration(node)) {
         return identString(node.name);
     }
@@ -340,6 +350,9 @@ export function identName(node) {
     if (ts.isComputedPropertyName(node)) {
         return identString(node);
     }
+    if (ts.isExportAssignment(node)) {
+        return node.expression.getText();
+    }
     if (ts.isUnionTypeNode(node)) {
         return `UnionType`;
     }
@@ -469,6 +482,22 @@ export function camelCaseToUpperSnakeCase(input) {
         .map(s => toUpperSnakeCase(s))
         .join('_');
 }
+export function snakeToLowCamelNode(node) {
+    if (!node.fileName) {
+        throw new Error("Invalid Convert");
+    }
+    const classname = path.basename(node.fileName).replace(".idl", "").replace(".d.ts", "");
+    return classname
+        .split('_')
+        .filter(word => word !== '')
+        .map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+}
 export function renameDtsToPeer(fileName, language, withFileExtension = true) {
     const renamed = "Ark"
         .concat(snakeCaseToCamelCase(fileName))
@@ -536,9 +565,7 @@ export function className(node) {
 export function nameEnumValues(enumTarget) {
     const prefix = "LEGACY";
     const nameToIndex = new Map();
-    enumTarget.members
-        .map(it => identName(it.name))
-        .forEach((name, index) => {
+    enumTarget.forEach((name, index) => {
         let upperCaseName;
         if (isUpperCase(name)) {
             upperCaseName = name;
@@ -654,4 +681,15 @@ export function rightmostIndexOf(array, predicate) {
     });
     return result;
 }
+// sort array using external key function or internal string property
+export function sorted(array, key) {
+    const comparator = new Intl.Collator();
+    if (typeof key === "function") {
+        return array.map(it => { return { sortKey: key(it), value: it }; })
+            .sort((a, b) => comparator.compare(a.sortKey, b.sortKey))
+            .map(it => it.value);
+    }
+    return array.map(it => it)
+        .sort((a, b) => comparator.compare(a[key], b[key]));
+}
 //# sourceMappingURL=util.js.map

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

@@ -30,7 +30,6 @@ export declare class IDLDependencyCollector implements IDLConverter<idl.IDLNode[
     visitPrimitiveType(): idl.IDLNode[];
     visitNamespace(decl: idl.IDLNamespace): idl.IDLNode[];
     visitInterface(decl: idl.IDLInterface): idl.IDLNode[];
-    protected visitSupertype(type: idl.IDLType | idl.IDLInterface): idl.IDLNode[];
     visitEnum(): idl.IDLNode[];
     visitTypedef(decl: idl.IDLTypedef): idl.IDLNode[];
     visitCallback(decl: idl.IDLCallback): idl.IDLNode[];
@@ -40,4 +39,6 @@ export declare class IDLDependencyCollector implements IDLConverter<idl.IDLNode[
     walk(node?: idl.IDLNode): idl.IDLNode[];
 }
 export declare function collectDependencies(resolver: ReferenceResolver, node: idl.IDLNode): idl.IDLNode[];
+export declare function filterRedundantMethodsOverloads(methods: idl.IDLMethod[]): idl.IDLMethod[];
+export declare function filterRedundantAttributesOverloads(properties: idl.IDLProperty[]): idl.IDLProperty[];
 //# sourceMappingURL=visitor.d.ts.map

package/build/lib/src/visitor.js

@@ -90,7 +90,7 @@ export class IDLDependencyCollector {
         return [
             ...decl.inheritance
                 .filter(it => it !== idl.IDLTopType)
-                .flatMap(it => this.visitSupertype(it)),
+                .flatMap(it => this.walk(it)),
             ...decl.properties
                 .filter(it => !it.isStatic)
                 .flatMap(it => this.walk(it.type)),
@@ -101,12 +101,6 @@ export class IDLDependencyCollector {
             ])
         ];
     }
-    visitSupertype(type) {
-        if (idl.isInterface(type)) {
-            return this.walk(idl.createReferenceType(type));
-        }
-        return this.walk(type);
-    }
     visitEnum() {
         return [];
     }
@@ -140,4 +134,112 @@ export class IDLDependencyCollector {
 export function collectDependencies(resolver, node) {
     return walkIDL(new IDLDependencyCollector(resolver), node);
 }
+function isFirstTypeSubsetOfSecond(first, second) {
+    if (idl.isOptionalType(second)) {
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first), idl.maybeUnwrapOptionalType(second));
+    }
+    if (idl.isUnionType(second)) {
+        const firstTypes = idl.isUnionType(first) ? first.types : [first];
+        const secondTypes = second.types;
+        return firstTypes.every(firstType => secondTypes.some(secondType => isFirstTypeSubsetOfSecond(firstType, secondType)));
+    }
+    return idl.printType(first) === idl.printType(second);
+}
+function isFirstParameterSubsetOfSecond(first, second) {
+    if (first === undefined)
+        return second.isOptional;
+    if (first.isOptional && !second.isOptional)
+        return false;
+    if (second.isOptional)
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first.type), idl.maybeUnwrapOptionalType(second.type));
+    return isFirstTypeSubsetOfSecond(first.type, second.type);
+}
+function isFirstMethodSubsetOfSecond(first, second) {
+    if (first.parameters.length > second.parameters.length)
+        return false;
+    if (first.isAsync !== second.isAsync)
+        return false;
+    if (first.isStatic !== second.isStatic)
+        return false;
+    if (second.parameters.some((secondParameter, idx) => !isFirstParameterSubsetOfSecond(first.parameters.at(idx), secondParameter)))
+        return false;
+    if (!isFirstTypeSubsetOfSecond(first.returnType, second.returnType))
+        return false;
+    return true;
+}
+function isFirstPropertySubsetOfSecond(first, second) {
+    if (idl.getExtAttribute(first, idl.IDLExtendedAttributes.Accessor) !==
+        idl.getExtAttribute(second, idl.IDLExtendedAttributes.Accessor))
+        return false;
+    if (first.isStatic !== second.isStatic)
+        return false;
+    if (first.isOptional && !second.isOptional)
+        return false;
+    if (second.isOptional)
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first.type), idl.maybeUnwrapOptionalType(second.type));
+    return isFirstTypeSubsetOfSecond(first.type, second.type);
+}
+function filterRedundantOverloadsSameNamed(entries) {
+    const entryToSupersets = new Map();
+    for (const entry of entries) {
+        entryToSupersets.set(entry, []);
+        for (const other of entries) {
+            if (entry === other)
+                continue;
+            if (idl.isMethod(entry) && idl.isMethod(other)) {
+                if (isFirstMethodSubsetOfSecond(entry, other))
+                    entryToSupersets.get(entry).push(other);
+            }
+            else if (idl.isProperty(entry) && idl.isProperty(other)) {
+                if (isFirstPropertySubsetOfSecond(entry, other))
+                    entryToSupersets.get(entry).push(other);
+            }
+            else {
+                throw new Error("Not implemented");
+            }
+        }
+    }
+    const visited = [];
+    const roots = [];
+    const visit = (method) => {
+        if (visited.includes(method))
+            return;
+        visited.push(method);
+        for (const superset of entryToSupersets.get(method)) {
+            visit(superset);
+        }
+        if (!entryToSupersets.get(method).some(it => roots.includes(it)))
+            roots.push(method);
+    };
+    entries.forEach(visit);
+    return roots;
+}
+export function filterRedundantMethodsOverloads(methods) {
+    const sameNamedGroups = new Map();
+    for (const method of methods) {
+        if (!sameNamedGroups.has(method.name))
+            sameNamedGroups.set(method.name, []);
+        sameNamedGroups.get(method.name).push(method);
+    }
+    const filtered = [];
+    for (const sameNamed of sameNamedGroups.values()) {
+        filtered.push(...filterRedundantOverloadsSameNamed(sameNamed));
+    }
+    // stabilizing order
+    return methods.filter(it => filtered.includes(it));
+}
+export function filterRedundantAttributesOverloads(properties) {
+    const sameNamedGroups = new Map();
+    for (const property of properties) {
+        if (!sameNamedGroups.has(property.name))
+            sameNamedGroups.set(property.name, []);
+        sameNamedGroups.get(property.name).push(property);
+    }
+    const filtered = [];
+    for (const sameNamed of sameNamedGroups.values()) {
+        filtered.push(...filterRedundantOverloadsSameNamed(sameNamed));
+    }
+    // stabilizing order
+    return properties.filter(it => filtered.includes(it));
+}
 //# sourceMappingURL=visitor.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.2",
+  "version": "2.1.7",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.12",
+    "@koalaui/interop": "1.7.1",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },

package/webidl2.js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Robin Berjon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.