@nu-art/ts-dependency-viewer-backend 0.400.7

package/index.d.ts

@@ -0,0 +1 @@
+export {};

package/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@nu-art/ts-dependency-viewer-backend",
+  "version": "0.400.7",
+  "description": "ts-dependency-viewer - Express & Typescript based backend framework Backend",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "thunderstorm",
+    "typescript",
+    "ts-dependency-viewer"
+  ],
+  "homepage": "https://github.com/nu-art-js/thunderstorm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@nu-art/ts-dependency-viewer-shared": "0.400.7",
+    "@nu-art/thunderstorm-backend": "0.400.7",
+    "@nu-art/thunderstorm-shared": "0.400.7",
+    "@nu-art/ts-common": "0.400.7",
+    "compression": "^1.7.4",
+    "d3": "7.8.2",
+    "d3-graphviz": "5.0.2",
+    "d3-selection": "3.0.0",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "react": "^18.0.0",
+    "ts-graphviz": "1.5.3"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
+    "@types/d3": "^7.4.0",
+    "@types/d3-graphviz": "^2.6.7"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}

package/runtime-type-resolver/parse-type.d.ts

@@ -0,0 +1,3 @@
+export declare function parseAllTypesFromFile(filePath: string): {
+    [key: string]: any;
+};

package/runtime-type-resolver/parse-type.js

@@ -0,0 +1,99 @@
+import * as ts from 'typescript';
+const resolvers = [
+    (descriptor, typeNode, checker) => {
+        if (!ts.isTypeLiteralNode(typeNode))
+            return;
+        descriptor.type = 'object';
+        descriptor.members = [];
+        typeNode.members.forEach(member => {
+            if (ts.isPropertySignature(member) && member.name && member.type) {
+                const memberDescriptor = { name: member.name.getText() };
+                parseTypeV2(memberDescriptor, member.type, checker);
+                descriptor.members.push(memberDescriptor);
+            }
+        });
+    },
+    (descriptor, typeNode, checker) => {
+        if (!ts.isFunctionTypeNode(typeNode))
+            return;
+        descriptor.type = 'function';
+        descriptor.parameters = [];
+        typeNode.parameters.forEach(paramNode => {
+            const paramDescriptor = { name: paramNode.name.getText() };
+            parseTypeV2(paramDescriptor, paramNode.type, checker);
+            descriptor.parameters.push(paramDescriptor);
+        });
+        // Resolve the return type of the function
+        descriptor.returnType = {};
+        parseTypeV2(descriptor.returnType, typeNode.type, checker);
+    },
+    (descriptor, typeNode, checker) => {
+        const types = checker.getTypeFromTypeNode(typeNode).aliasTypeArguments;
+        if (!types)
+            return;
+        descriptor.genericParams = [];
+        types.forEach(genericType => {
+            const paramDescriptor = { name: genericType.symbol.name };
+            paramDescriptor.type = checker.symbolToEntityName(checker.getBaseConstraintOfType(genericType).aliasSymbol, ts.SymbolFlags.Alias, undefined, undefined)
+                .getText();
+            // const constraintOfType = checker.getBaseConstraintOfType(genericType) ?? genericType;
+            // parseTypeV2(paramDescriptor, checker.typeToTypeNode(constraintOfType, undefined, undefined)!, checker);
+            descriptor.genericParams.push(paramDescriptor);
+        });
+    },
+    (descriptor, typeNode, checker) => {
+        if (descriptor.type !== undefined)
+            return;
+        // typeNode.typeName
+        descriptor.type = checker.typeToString(checker.getTypeFromTypeNode(typeNode));
+    },
+    (descriptor, typeNode, checker) => {
+        descriptor.typeLiteral = checker.typeToString(checker.getTypeFromTypeNode(typeNode));
+    },
+];
+function parseTypeV2(descriptor, typeNode, checker) {
+    return resolvers.reduce((descriptor, resolver) => {
+        resolver(descriptor, typeNode, checker);
+        return descriptor;
+    }, descriptor);
+}
+function collectTypes(sourceFile) {
+    const types = {};
+    const visit = (node) => {
+        if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+            const typeName = node.name.text;
+            let typeNode;
+            if (ts.isTypeAliasDeclaration(node)) {
+                typeNode = node.type;
+            }
+            else if (ts.isInterfaceDeclaration(node)) {
+                const members = node.members;
+                typeNode = ts.factory.createTypeLiteralNode(members);
+            }
+            if (typeNode) {
+                types[typeName] = typeNode;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return types;
+}
+export function parseAllTypesFromFile(filePath) {
+    const program = ts.createProgram([filePath], {});
+    const checker = program.getTypeChecker();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) {
+        throw new Error(`File ${filePath} not found`);
+    }
+    const types = collectTypes(sourceFile);
+    const parsedTypes = {};
+    for (const typeName in types) {
+        const typeNode = types[typeName];
+        const descriptor = { name: typeName };
+        parsedTypes[typeName] = parseTypeV2(descriptor, typeNode, checker);
+    }
+    return parsedTypes;
+}
+const parseTypeFromFile1 = parseAllTypesFromFile('./file.ts');
+console.log('output:', JSON.stringify(parseTypeFromFile1, null, 2));