@idlizer/core 2.0.15

package/build/lib/src/util.js

@@ -0,0 +1,622 @@
+/*
+ * 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 path from 'path';
+import * as fs from "fs";
+import * as ts from "typescript";
+import { Language } from './Language';
+/** True if this is visible outside this file, false otherwise */
+export function isNodePublic(node) {
+    return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Public) !== 0;
+}
+export function nameOrNull(name) {
+    if (name == undefined)
+        return undefined;
+    if (ts.isIdentifier(name)) {
+        return ts.idText(name);
+    }
+    return undefined;
+}
+export function isNamedDeclaration(node) {
+    return ("name" in node);
+}
+export function asString(node) {
+    if (node === undefined)
+        return "undefined node";
+    if (ts.isIdentifier(node))
+        return ts.idText(node);
+    if (ts.isQualifiedName(node))
+        return `${identName(node.left)}.${identName(node.right)}`;
+    if (ts.isStringLiteral(node))
+        return node.text;
+    if (ts.isTypeReferenceNode(node))
+        return `${ts.SyntaxKind[node.kind]}(${asString(node.typeName)})`;
+    if (ts.isImportTypeNode(node))
+        return `${ts.SyntaxKind[node.kind]}(${asString(node.qualifier)})`;
+    if (isNamedDeclaration(node)) {
+        if (node.name === undefined) {
+            return `${ts.SyntaxKind[node.kind]}(undefined name)`;
+        }
+        else {
+            return `${ts.SyntaxKind[node.kind]}(${asString(node.name)})`;
+        }
+    }
+    else {
+        return `${ts.SyntaxKind[node.kind]}`;
+    }
+}
+export function arrayAt(array, index) {
+    return array ? array[index >= 0 ? index : array.length + index] : undefined;
+}
+export function getComment(sourceFile, node) {
+    const commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
+    if (!commentRanges)
+        return "";
+    return commentRanges
+        .map(range => sourceFile.getFullText().slice(range.pos, range.end))
+        .join("\n");
+}
+export function getSymbolByNode(typechecker, node) {
+    return typechecker.getSymbolAtLocation(node);
+}
+export function getDeclarationsByNode(typechecker, node) {
+    var _a, _b;
+    return (_b = (_a = getSymbolByNode(typechecker, node)) === null || _a === void 0 ? void 0 : _a.getDeclarations()) !== null && _b !== void 0 ? _b : [];
+}
+export function findRealDeclarations(typechecker, node) {
+    const declarations = getDeclarationsByNode(typechecker, node);
+    const first = declarations[0];
+    if (first && ts.isExportAssignment(first)) {
+        return findRealDeclarations(typechecker, first.expression);
+    }
+    else {
+        return declarations;
+    }
+}
+export function getExportedDeclarationNameByDecl(declaration) {
+    let declName = declaration.name ? ts.idText(declaration.name) : undefined;
+    let current = declaration;
+    while (current != undefined && !ts.isSourceFile(current)) {
+        current = current.parent;
+    }
+    let source = current;
+    let exportedName = declName;
+    source.forEachChild(it => {
+        if (ts.isExportDeclaration(it)) {
+            let clause = it.exportClause;
+            if (clause && ts.isNamedExportBindings(clause) && ts.isNamedExports(clause)) {
+                clause.elements.forEach(it => {
+                    let propName = it.propertyName ? ts.idText(it.propertyName) : undefined;
+                    let property = ts.idText(it.name);
+                    if (propName == declName) {
+                        exportedName = property;
+                    }
+                });
+            }
+        }
+    });
+    return exportedName;
+}
+export function getExportedDeclarationNameByNode(typechecker, node) {
+    let declarations = getDeclarationsByNode(typechecker, node);
+    if (declarations.length == 0)
+        return undefined;
+    return getExportedDeclarationNameByDecl(declarations[0]);
+}
+function hasModifier(modifierLikes, modifier) {
+    return (modifierLikes === null || modifierLikes === void 0 ? void 0 : modifierLikes.find(it => it.kind === modifier)) != undefined;
+}
+export function isReadonly(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.ReadonlyKeyword);
+}
+export function isExport(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.ExportKeyword);
+}
+export function isAbstract(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.AbstractKeyword);
+}
+export function isStatic(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.StaticKeyword);
+}
+export function isAsync(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.AsyncKeyword);
+}
+export function isPrivate(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.PrivateKeyword);
+}
+export function isProtected(modifierLikes) {
+    return hasModifier(modifierLikes, ts.SyntaxKind.ProtectedKeyword);
+}
+export function getLineNumberString(sourceFile, position) {
+    let pos = ts.getLineAndCharacterOfPosition(sourceFile, position);
+    return `${pos.line + 1}:${pos.character}`;
+}
+export function isDefined(value) {
+    return !!value;
+}
+export function capitalize(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+export function capitalizeConstantName(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+}
+export function dropLast(text, chars) {
+    return text.substring(0, text.length - chars);
+}
+export function dropSuffix(text, suffix) {
+    if (!text.endsWith(suffix))
+        return text;
+    return dropLast(text, suffix.length);
+}
+export function toSet(option) {
+    let set = new Set();
+    if (option) {
+        option
+            .split(",")
+            .forEach(it => set.add(it));
+    }
+    return set;
+}
+export function getOrPut(map, key, create) {
+    const gotten = map.get(key);
+    if (gotten) {
+        return gotten;
+    }
+    const created = create(key);
+    map.set(key, created);
+    return created;
+}
+export function indentedBy(input, indentedBy) {
+    if (input.length > 0 || input.endsWith('\n')) {
+        let space = "";
+        for (let i = 0; i < indentedBy; i++)
+            space += "    ";
+        return `${space}${input}`;
+    }
+    else {
+        return "";
+    }
+}
+export function typeOrUndefined(type) {
+    var _a;
+    let needUndefined = true;
+    if (ts.isUnionTypeNode(type)) {
+        (_a = type.types) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            if (it.kind == ts.SyntaxKind.UndefinedKeyword)
+                needUndefined = false;
+        });
+    }
+    if (!needUndefined)
+        return type;
+    return ts.factory.createUnionTypeNode([
+        type,
+        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+    ]);
+}
+export function forEachExpanding(array, action) {
+    let i = 0;
+    while (true) {
+        if (i === array.length)
+            break;
+        action(array[i]);
+        i += 1;
+    }
+}
+export function isTypeParamSuitableType(type) {
+    if (ts.isTypeReferenceNode(type)) {
+        return !['boolean', 'number', 'string', 'undefined', 'any'].includes(type.typeName.getText());
+    }
+    return false;
+}
+export function heritageTypes(typechecker, clause) {
+    return clause
+        .types
+        .map(it => {
+        let type = typechecker.getTypeAtLocation(it.expression);
+        let typeNode = typechecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation);
+        if (typeNode && ts.isTypeReferenceNode(typeNode))
+            return typeNode;
+        return undefined;
+    })
+        .filter(it => it != undefined);
+}
+export function heritageDeclarations(typechecker, clause) {
+    return clause
+        .types
+        .map(it => {
+        var _a;
+        let decls = getDeclarationsByNode(typechecker, it.expression);
+        return (_a = decls[0]) !== null && _a !== void 0 ? _a : undefined;
+    })
+        .filter(isDefined);
+}
+export function typeName(type) {
+    const entityName = typeEntityName(type);
+    if (!entityName)
+        return undefined;
+    if (ts.isIdentifier(entityName))
+        return ts.idText(entityName);
+    if (ts.isQualifiedName(entityName)) {
+        // a.b.c is QualifiedName((QualifiedName a, b), c) so the right one is always an Identifier?
+        if (!ts.isIdentifier(entityName.right))
+            throw new Error(`Unexpected right of QualifiedName ${asString(entityName.right)}`);
+        return ts.idText(entityName.right);
+    }
+}
+export function typeEntityName(type) {
+    if (ts.isTypeReferenceNode(type))
+        return type.typeName;
+    if (ts.isTypeQueryNode(type))
+        return type.exprName;
+    if (ts.isImportTypeNode(type))
+        return type.qualifier;
+    throw new Error("unsupported");
+}
+export function zip(left, right) {
+    if (left.length != right.length)
+        throw new Error("Arrays of different length");
+    return left.map((_, i) => [left[i], right[i]]);
+}
+export function identNameWithNamespace(node, language) {
+    let parent = node.parent;
+    while (parent && !ts.isModuleDeclaration(parent))
+        parent = parent.parent;
+    if (parent) {
+        const separator = language === Language.CPP ? '_' : '.';
+        return `${identName(parent.name)}${separator}${identName(node)}`;
+    }
+    else {
+        return identName(node);
+    }
+}
+export function identName(node) {
+    if (!node)
+        return undefined;
+    if (node.kind == ts.SyntaxKind.AnyKeyword)
+        return `any`;
+    if (node.kind == ts.SyntaxKind.ObjectKeyword)
+        return `object`;
+    if (node.kind == ts.SyntaxKind.StringKeyword)
+        return `string`;
+    if (node.kind == ts.SyntaxKind.BooleanKeyword)
+        return `boolean`;
+    if (node.kind == ts.SyntaxKind.BigIntKeyword)
+        return `bigint`;
+    if (node.kind == ts.SyntaxKind.NumberKeyword)
+        return `number`;
+    if (node.kind == ts.SyntaxKind.VoidKeyword)
+        return `void`;
+    if (node.kind == ts.SyntaxKind.UndefinedKeyword)
+        return `undefined`;
+    if (ts.isVariableDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isTypeReferenceNode(node)) {
+        return identString(node.typeName);
+    }
+    if (ts.isArrayTypeNode(node)) {
+        return `Array`;
+    }
+    if (ts.isQualifiedName(node)) {
+        return identName(node.right);
+    }
+    if (ts.isModuleDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isFunctionDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isPropertyDeclaration(node)) {
+        // TODO: mention parent's name
+        return identString(node.name);
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isClassDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isMethodDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isEnumDeclaration(node)) {
+        return identString(node.name);
+    }
+    if (ts.isEnumMember(node)) {
+        return identString(node.name);
+    }
+    if (ts.isComputedPropertyName(node)) {
+        return identString(node);
+    }
+    if (ts.isUnionTypeNode(node)) {
+        return `UnionType`;
+    }
+    if (ts.isFunctionTypeNode(node)) {
+        return `FunctionType`;
+    }
+    if (ts.isIdentifier(node))
+        return identString(node);
+    if (ts.isImportTypeNode(node))
+        return `imported ${identString(node.qualifier)}`;
+    if (ts.isTypeLiteralNode(node))
+        return `TypeLiteral`;
+    if (ts.isTupleTypeNode(node))
+        return `TupleType`;
+    if (ts.isIndexSignatureDeclaration(node))
+        return `IndexSignature`;
+    if (ts.isIndexedAccessTypeNode(node))
+        return `IndexedAccess`;
+    if (ts.isTemplateLiteralTypeNode(node))
+        return `TemplateLiteral`;
+    if (ts.isParameter(node))
+        return `Parameter`;
+    if (ts.isParenthesizedTypeNode(node))
+        return identName(node.type);
+    if (ts.isIntersectionTypeNode(node))
+        return node.types.map(it => identName(it)).join("&");
+    if (node.kind === ts.SyntaxKind.UnknownKeyword)
+        return `UnknownKeyword`;
+    throw new Error(`Unknown: ${ts.SyntaxKind[node.kind]}`);
+}
+export function identString(node) {
+    if (!node)
+        return undefined;
+    if (ts.isStringLiteral(node))
+        return node.text;
+    if (ts.isNumericLiteral(node))
+        return node.text;
+    if (ts.isIdentifier(node))
+        return ts.idText(node);
+    if (ts.isQualifiedName(node))
+        return `${identString(node.left)}.${identName(node.right)}`;
+    if (ts.isComputedPropertyName(node))
+        return "<computed property>";
+    throw new Error("Unknown");
+}
+export const defaultCompilerOptions = {
+    target: ts.ScriptTarget.ES5,
+    module: ts.ModuleKind.CommonJS,
+    noLib: true,
+    types: []
+};
+export function serializerBaseMethods() {
+    const program = ts.createProgram([
+        "./utils/ts/SerializerBase.ts",
+        "./utils/ts/types.ts",
+    ], defaultCompilerOptions);
+    const serializerDecl = program.getSourceFiles()
+        .find(it => it.fileName.includes("SerializerBase"));
+    // TODO: pack classes with npm package
+    if (serializerDecl === undefined)
+        return [];
+    const methods = [];
+    visit(serializerDecl);
+    return methods;
+    function visit(node) {
+        if (ts.isSourceFile(node))
+            node.statements.forEach(visit);
+        if (ts.isClassDeclaration(node))
+            node.members.filter(ts.isMethodDeclaration).forEach(visit);
+        if (ts.isMethodDeclaration(node))
+            methods.push(node.name.getText(serializerDecl));
+    }
+}
+export function getNameWithoutQualifiersRight(node) {
+    if (!node)
+        return undefined;
+    if (ts.isQualifiedName(node)) {
+        return identName(node.right);
+    }
+    if (ts.isIdentifier(node)) {
+        return identName(node);
+    }
+    throw new Error("Impossible");
+}
+export function getNameWithoutQualifiersLeft(node) {
+    if (!node)
+        return undefined;
+    if (ts.isQualifiedName(node)) {
+        return identName(node.left);
+    }
+    if (ts.isIdentifier(node)) {
+        return identName(node);
+    }
+    throw new Error("Impossible");
+}
+export function snakeCaseToCamelCase(input, tailToLowerCase = false) {
+    return input
+        .split("_")
+        .map(it => capitalize(tailToLowerCase ? it.toLowerCase() : it))
+        .join("");
+}
+export function toCamelCase(input) {
+    return input
+        .replace(/([-_][a-z])/g, group => group.toUpperCase().replace('-', '').replace('_', ''))
+        .replace(/^[A-Z]/, match => match.toLowerCase());
+}
+export function isUpperCase(s) {
+    return s === s.toUpperCase();
+}
+function isLowerCase(s) {
+    return s === s.toLowerCase();
+}
+function isDigit(s) {
+    return s >= '0' && s <= '9';
+}
+export function camelCaseToUpperSnakeCase(input) {
+    function boundaryFromLowerToUpperCase(s1, s2) {
+        return s2 !== undefined && (isLowerCase(s1) && !isDigit(s1)) && (isUpperCase(s2)) ? '_' : '';
+    }
+    function toUpperSnakeCase(s) {
+        return Array.from(s)
+            .map((c, i) => `${c.toUpperCase()}${boundaryFromLowerToUpperCase(c, s[i + 1])}`)
+            .join('');
+    }
+    return input.split('_')
+        .filter(s => s !== "")
+        .map(s => toUpperSnakeCase(s))
+        .join('_');
+}
+export function renameDtsToPeer(fileName, language, withFileExtension = true) {
+    const renamed = "Ark"
+        .concat(snakeCaseToCamelCase(fileName))
+        .replace(".d.ts", "")
+        .replace(".idl", "")
+        .concat("Peer");
+    if (withFileExtension) {
+        return renamed.concat(language.extension);
+    }
+    return renamed;
+}
+export function renameDtsToComponent(fileName, language, withFileExtension = true) {
+    const renamed = "Ark"
+        .concat(snakeCaseToCamelCase(fileName))
+        .replace(".d.ts", "")
+        .replace(".idl", "");
+    if (withFileExtension) {
+        return renamed.concat(language.extension);
+    }
+    return renamed;
+}
+export function renameDtsToInterfaces(fileName, language, withFileExtension = true) {
+    const renamed = "Ark"
+        .concat(snakeCaseToCamelCase(fileName), "Interfaces")
+        .replace(".d.ts", "")
+        .replace(".idl", "");
+    if (withFileExtension) {
+        return renamed.concat(language.extension);
+    }
+    return renamed;
+}
+export function renameClassToBuilderClass(className, language, withFileExtension = true) {
+    const renamed = "Ark"
+        .concat(snakeCaseToCamelCase(className))
+        .concat("Builder");
+    if (withFileExtension) {
+        return renamed.concat(language.extension);
+    }
+    return renamed;
+}
+export function renameClassToMaterialized(className, language, withFileExtension = true) {
+    const name = className.endsWith("Internal") ? className.substring(0, className.length - "Internal".length) : className;
+    const renamed = "Ark"
+        .concat(snakeCaseToCamelCase(name))
+        .concat("Materialized");
+    if (withFileExtension) {
+        return renamed.concat(language.extension);
+    }
+    return renamed;
+}
+export function importTypeName(type, asType = false) {
+    return asType ? "object" : identName(type.qualifier);
+}
+export function throwException(message) {
+    throw new Error(message);
+}
+export function className(node) {
+    var _a;
+    return (_a = nameOrNull(node.name)) !== null && _a !== void 0 ? _a : throwException(`Nameless component ${asString(node)}`);
+}
+/**
+ * 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 function nameEnumValues(enumTarget) {
+    const prefix = "LEGACY";
+    const nameToIndex = new Map();
+    enumTarget.members
+        .map(it => identName(it.name))
+        .forEach((name, index) => {
+        let upperCaseName;
+        if (isUpperCase(name)) {
+            upperCaseName = name;
+            const i = nameToIndex.get(upperCaseName);
+            if (i !== undefined) {
+                nameToIndex.set(`${prefix}_${upperCaseName}`, i);
+            }
+        }
+        else {
+            upperCaseName = camelCaseToUpperSnakeCase(name);
+            if (nameToIndex.has(upperCaseName)) {
+                upperCaseName = `${prefix}_${upperCaseName}`;
+            }
+        }
+        nameToIndex.set(upperCaseName, index);
+    });
+    const enumValues = new Array(nameToIndex.size);
+    for (const [name, index] of nameToIndex.entries()) {
+        enumValues[index] = name;
+    }
+    return enumValues;
+}
+export function groupBy(values, selector) {
+    const map = new Map();
+    values.forEach(value => {
+        const key = selector(value);
+        getOrPut(map, key, it => []).push(value);
+    });
+    return map;
+}
+export function removeExt(filename) {
+    return filename.replaceAll(path.extname(filename), '');
+}
+export function warn(message) {
+    console.log(`WARNING: ${message}`);
+}
+export function hashCodeFromString(value) {
+    let hash = 5381;
+    for (let i = 0; i < value.length; i++) {
+        hash = (hash * 33) ^ value.charCodeAt(i);
+        hash |= 0;
+    }
+    return hash;
+}
+export function forceWriteFile(filePath, content) {
+    path.dirname(filePath).split(path.sep).reduce((last, dir) => {
+        const dirPath = path.join(last, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath);
+        }
+        return dirPath;
+    }, ".");
+    fs.writeFileSync(filePath, content);
+}
+export function findVersion() {
+    if (process.env.npm_package_version)
+        return process.env.npm_package_version;
+    let packageJson = path.join(__dirname, '..', 'package.json');
+    try {
+        let json = fs.readFileSync(packageJson).toString();
+        return json ? JSON.parse(json).version : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+export function zipMany(...xs) {
+    const max = xs.reduce((max, it) => it.length > max ? it.length : max, 0);
+    const result = [];
+    for (let i = 0; i < max; ++i) {
+        const row = [];
+        for (const x of xs) {
+            const element = i < x.length
+                ? x[i]
+                : undefined;
+            row.push(element);
+        }
+        result.push(row);
+    }
+    return result;
+}
+//# sourceMappingURL=util.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@idlizer/core",
+  "version": "2.0.15",
+  "description": "",
+  "types": "build/lib/src/index.d.ts",
+  "exports": {
+    ".": [
+      "./build/lib/src/index.js"
+    ],
+    "./idl": [
+      "./build/lib/src/idl.js"
+    ]
+  },
+  "typesVersions": {
+    "*": {
+      "idl": [
+        "build/lib/src/idl.d.ts"
+      ],
+      "*": [
+        "build/lib/src/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "build/lib/**/*.js",
+    "build/lib/**/*.d.ts",
+    "webidl2.js/dist/**/*.js",
+    "webidl2.js/package.json"
+  ],
+  "type": "module",
+  "engines": {
+    "npm": ">= 8",
+    "node": ">= 18"
+  },
+  "keywords": [],
+  "dependencies": {
+    "@koalaui/interop": "2.0.15",
+    "typescript": "4.9.5",
+    "@types/node": "^18.0.0",
+    "commander": "^10.0.0",
+    "comment-parser": "^1.4.1",
+    "cross-env": "^7.0.3",
+    "minimist": "^1.2.8"
+  },
+  "scripts": {
+    "clean": "rimraf -g build",
+    "compile": "tsc -b ."
+  }
+}

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.