@idlizer/core 2.1.0 → 2.1.5

package/build/lib/src/peer-generation/unions.js

@@ -21,6 +21,10 @@ export class UnionFlattener {
     constructor(resolver) {
         this.resolver = resolver;
     }
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return [];
+    }
     convertUnion(type) {
         return type.types.flatMap(it => convertType(this, it));
     }
@@ -34,7 +38,7 @@ export class UnionFlattener {
     convertContainer(type) {
         return [type];
     }
-    convertImport(type, importClause) {
+    convertTypeReferenceAsImport(type, importClause) {
         return [type];
     }
     convertPrimitiveType(type) {
@@ -111,8 +115,8 @@ export class UnionRuntimeTypeChecker {
     }
 }
 export function flattenUnionType(library, type) {
-    const unionFlattener = new UnionFlattener(library);
     if (isUnionType(type)) {
+        const unionFlattener = new UnionFlattener(library);
         const allTypes = type.types.flatMap(it => convertType(unionFlattener, it));
         const uniqueTypes = new Set(allTypes);
         return uniqueTypes.size === allTypes.length ? type : collapseTypes(Array.from(uniqueTypes));

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

@@ -0,0 +1,3 @@
+import { IDLFile, IDLNode, IDLNamedNode } from "./idl";
+export declare function resolveNamedNode(target: string[], pov: IDLNode | undefined, corpus: IDLFile[]): IDLNamedNode | undefined;
+//# sourceMappingURL=resolveNamedNode.d.ts.map

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

@@ -53,6 +53,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;
@@ -67,6 +68,7 @@ export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclar
  */
 export declare function nameEnumValues(enumTarget: ts.EnumDeclaration): 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;
 export declare function warn(message: string): void;
 export declare function hashCodeFromString(value: string): number;
@@ -83,4 +85,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

@@ -300,6 +300,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 +343,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 +475,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))
@@ -569,6 +591,12 @@ export function groupBy(values, selector) {
     });
     return map;
 }
+export function groupByIndexed(values, selector) {
+    const map = new Map();
+    values.forEach((it, index) => getOrPut(map, selector(it), () => [])
+        .push([it, index]));
+    return map;
+}
 export function removeExt(filename) {
     return filename.replaceAll(path.extname(filename), '');
 }
@@ -648,4 +676,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[];

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 [];
     }

package/package.json

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

package/webidl2.js/dist/webidl2.js

@@ -1661,7 +1661,7 @@ __webpack_require__.r(__webpack_exports__);
  * @param {string} identifier
  */
 function unescape(identifier) {
-  return identifier.startsWith("_") ? identifier.slice(1) : identifier;
+  return identifier;
 }
 
 /** @typedef {'callbackInterface'|'dictionary'|'interface'|'mixin'|'namespace'} ExtendableInterfaces */
@@ -1829,13 +1829,13 @@ function return_type(tokeniser, typeName) {
     typ.tokens.closeRT = closeRT;
     return typ;
   } while (false);
-  const typ = _type_js__WEBPACK_IMPORTED_MODULE_0__.Type.parse(tokeniser, typeName || "return-type");
+  const typ = Type.parse(tokeniser, typeName || "return-type");
   if (typ) {
     return typ;
   }
   const voidToken = tokeniser.consume("void");
   if (voidToken) {
-    const ret = new _type_js__WEBPACK_IMPORTED_MODULE_0__.Type({
+    const ret = new Type({
       source: tokeniser.source,
       tokens: { base: voidToken },
     });
@@ -3109,9 +3109,8 @@ function generic_type(tokeniser, typeName) {
     tokeniser.error(`No opening bracket after ${base.value}`);
   switch (base.value) {
     case "Promise": {
-      if (tokeniser.probe("["))
-        tokeniser.error("Promise type cannot have extended attribute");
       const subtype =
+        (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.type_with_extended_attributes)(tokeniser, typeName) ||
         (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.return_type)(tokeniser, typeName) ||
         tokeniser.error("Missing Promise subtype");
       ret.subtype.push(subtype);
@@ -3757,6 +3756,7 @@ function tokenise(str) {
           trivia,
           line,
           index,
+          position: lastCharIndex,
         });
         trivia = "";
         lastCharIndex += punctuation.length;
@@ -3783,6 +3783,7 @@ function tokenise(str) {
     trivia,
     line,
     index,
+    position: lastCharIndex,
   });
 
   return tokens;
@@ -3797,7 +3798,14 @@ function tokenise(str) {
     re.lastIndex = lastCharIndex;
     const result = re.exec(str);
     if (result) {
-      tokens.push({ type, value: result[0], trivia, line, index });
+      tokens.push({
+        type,
+        value: result[0],
+        trivia,
+        line,
+        index,
+        position: lastCharIndex,
+      });
       if (!noFlushTrivia) {
         trivia = "";
       }
@@ -4251,7 +4259,8 @@ function* checkInterfaceMemberDuplication(defs, i) {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   parse: () => (/* binding */ parse)
+/* harmony export */   parse: () => (/* binding */ parse),
+/* harmony export */   parseType: () => (/* binding */ parseType)
 /* harmony export */ });
 /* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./tokeniser.js */ "./lib/tokeniser.js");
 /* harmony import */ var _productions_enum_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./productions/enum.js */ "./lib/productions/enum.js");
@@ -4367,6 +4376,20 @@ function parse(str, options = {}) {
   return parseByTokens(tokeniser, options);
 }
 
+/**
+ * @param {string} str
+ * @param {string} fileName
+ */
+function parseType(str, fileName) {
+  const tokeniser = new _tokeniser_js__WEBPACK_IMPORTED_MODULE_0__.Tokeniser(str);
+  // @ts-ignore (See Tokeniser.source in supplement.d.ts)
+  tokeniser.source.name = fileName;
+  return (
+    (0,_productions_helpers_js__WEBPACK_IMPORTED_MODULE_15__.type_with_extended_attributes)(tokeniser, "type") ||
+    (0,_productions_helpers_js__WEBPACK_IMPORTED_MODULE_15__.return_type)(tokeniser, "return-type")
+  );
+}
+
 
 /***/ }),
 
@@ -4516,6 +4539,8 @@ function write(ast, { templates: ts = templates } = {}) {
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
 /*!******************!*\
   !*** ./index.js ***!
   \******************/
@@ -4523,6 +4548,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   WebIDLParseError: () => (/* reexport safe */ _lib_tokeniser_js__WEBPACK_IMPORTED_MODULE_3__.WebIDLParseError),
 /* harmony export */   parse: () => (/* reexport safe */ _lib_webidl2_js__WEBPACK_IMPORTED_MODULE_0__.parse),
+/* harmony export */   parseType: () => (/* reexport safe */ _lib_webidl2_js__WEBPACK_IMPORTED_MODULE_0__.parseType),
 /* harmony export */   validate: () => (/* reexport safe */ _lib_validator_js__WEBPACK_IMPORTED_MODULE_2__.validate),
 /* harmony export */   write: () => (/* reexport safe */ _lib_writer_js__WEBPACK_IMPORTED_MODULE_1__.write)
 /* harmony export */ });
@@ -4541,6 +4567,8 @@ __webpack_require__.r(__webpack_exports__);
 
 if (false) {}
 
+})();
+
 /******/ 	return __webpack_exports__;
 /******/ })()
 ;

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

@@ -1,2 +0,0 @@
-export declare function deepMergeConfig<T extends object>(defaults: T, custom: Partial<T>): T;
-//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2025 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.
- */
-function isObject(i) {
-    if (typeof i !== 'object')
-        return false;
-    if (Array.isArray(i))
-        return false;
-    return true;
-}
-export function deepMergeConfig(defaults, custom) {
-    if (custom === undefined)
-        return defaults;
-    const result = Object.assign({}, defaults);
-    for (const key in custom) {
-        if (Object.prototype.hasOwnProperty.call(custom, key)) {
-            const defaultValue = result[key];
-            const customValue = custom[key];
-            if (isObject(defaultValue) && isObject(customValue)) {
-                Object.assign(result, { [key]: deepMergeConfig(defaultValue, customValue) });
-            }
-            else {
-                if (isObject(defaultValue))
-                    throw new Error("Replacing default object value with custom non-object");
-                Object.assign(result, { [key]: customValue });
-            }
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=configMerge.js.map