@idlizer/core 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

package/build/lib/src/util.js

@@ -14,137 +14,13 @@
  */
 import * as path from 'path';
 import * as fs from "fs";
-import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
-import { isInExternalModule } from './peer-generation/modules';
+import { getModuleFor, isInExternalModule } from './peer-generation/modules';
 import { getInternalClassName, getInternalClassQualifiedName } from './peer-generation/Materialized';
-/** 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;
 }
@@ -191,22 +67,6 @@ export function indentedBy(input, indentedBy) {
         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) {
@@ -216,56 +76,6 @@ export function forEachExpanding(array, action) {
         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");
@@ -278,178 +88,6 @@ export function zipStrip(left, right) {
     }
     return result;
 }
-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.isThisTypeNode(node)) {
-        return 'this';
-    }
-    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.isExportAssignment(node)) {
-        return node.expression.getText();
-    }
-    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("_")
@@ -550,16 +188,9 @@ export function renameClassToMaterialized(className, language, withFileExtension
     }
     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
@@ -693,8 +324,12 @@ export function sorted(array, key) {
 }
 export function mapLibraryName(node, lang, mapping, prefix = "@") {
     var _a, _b;
+    const module = getModuleFor(node);
+    if (module.tsLikePackage !== undefined) {
+        return `^` + module.tsLikePackage;
+    }
     const packageName = idl.getPackageName(node);
-    return (_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`;
+    return `^` + ((_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`);
 }
 function getExtractorClass(target, toPtr = true) {
     if (isInExternalModule(target)) {
@@ -716,4 +351,54 @@ export function getExtractor(target, lang, toPtr = true) {
     const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
     return { receiver, method };
 }
+export function getTransformer(library, from, to) {
+    const convertor = library.createTypeNameConvertor(Language.CPP);
+    return {
+        receiver: "extractors",
+        method: `transform_${convertor.convert(from)}_to_${convertor.convert(to)}`
+    };
+}
+export function removePoints(s) {
+    return s.split(/[\.\-]/g).join('_');
+}
+export function scanDirectory(dir, fileFilter, recursive = false) {
+    const dirsToVisit = [path.resolve(dir)];
+    const result = [];
+    while (dirsToVisit.length > 0) {
+        let dir = dirsToVisit.pop();
+        let dirents = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of dirents) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                if (fileFilter(fullPath)) {
+                    result.push(fullPath);
+                }
+            }
+            else if (recursive && entry.isDirectory()) {
+                dirsToVisit.push(fullPath);
+            }
+        }
+    }
+    return result;
+}
+export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = false) {
+    if (typeof fileFilter === 'undefined')
+        return scanInputDirs(inputDirs, (_) => true, recursive);
+    if (typeof fileFilter === 'string')
+        return scanInputDirs(inputDirs, (file) => file.endsWith(fileFilter), recursive);
+    const resolvedInputDirs = inputDirs.map(dir => path.resolve(dir));
+    console.log("Resolved input directories:", resolvedInputDirs);
+    return resolvedInputDirs.flatMap(dir => {
+        if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+            console.log(`Processing all definitions from directory: ${dir}`);
+            return scanDirectory(dir, fileFilter, recursive);
+        }
+        else {
+            console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
+            return [];
+        }
+    }).sort((a, b) => {
+        return path.basename(a).localeCompare(path.basename(b));
+    });
+}
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,53 +1,49 @@
 {
-  "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-3a",
-  "description": "",
-  "types": "build/lib/src/index.d.ts",
-  "exports": {
-    ".": [
-      "./build/lib/src/index.js"
+    "name": "@idlizer/core",
+    "version": "2.1.10-arktscgen-5",
+    "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"
     ],
-    "./idl": [
-      "./build/lib/src/idl.js"
-    ]
-  },
-  "typesVersions": {
-    "*": {
-      "idl": [
-        "build/lib/src/idl.d.ts"
-      ],
-      "*": [
-        "build/lib/src/index.d.ts"
-      ]
+    "engines": {
+        "npm": ">= 8",
+        "node": ">= 18"
+    },
+    "keywords": [],
+    "devDependencies": {
+        "@koalaui/harness": "1.7.6+devel",
+        "@koalaui/ets-tsc": "4.9.5-r5",
+        "mocha": "^9.2.2",
+        "ts-node": "^10.9.2",
+        "typescript": "4.9.5",
+        "@types/node": "^18.0.0"
+    },
+    "scripts": {
+        "test": "mocha",
+        "clean": "rimraf -g build",
+        "compile:self": "tsc -b .",
+        "compile": "npm run compile:self"
     }
-  },
-  "files": [
-    "build/lib/**/*.js",
-    "build/lib/**/*.d.ts",
-    "webidl2.js/dist/**/*.js",
-    "webidl2.js/package.json"
-  ],
-  "engines": {
-    "npm": ">= 8",
-    "node": ">= 18"
-  },
-  "keywords": [],
-  "dependencies": {
-    "@koalaui/interop": "1.7.10",
-    "typescript": "4.9.5",
-    "@types/node": "^18.0.0"
-  },
-  "devDependencies": {
-    "@koalaui/harness": "1.7.6+devel",
-    "@koalaui/ets-tsc": "4.9.5-r5",
-    "@types/mocha": "^9.1.0",
-    "mocha": "^9.2.2",
-    "ts-node": "^10.9.2"
-  },
-  "scripts": {
-    "test": "mocha",
-    "clean": "rimraf -g build",
-    "compile:self": "tsc -b .",
-    "compile": "npm run compile:self"
-  }
 }