@nexus-ioc/language-service 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/language-service/ns-language-service.d.ts

@@ -0,0 +1,19 @@
+import type ts from "typescript/lib/tsserverlibrary";
+import type { Logger } from "../logger";
+import type { CompilerOptions } from "./types";
+export type PluginConfig = {
+    debug?: boolean;
+    logPath?: string;
+};
+export declare class NsLanguageService {
+    private readonly project;
+    private readonly host;
+    private readonly _tsLS;
+    private readonly config;
+    private readonly _logger;
+    private options;
+    constructor(project: ts.server.Project, host: ts.server.ServerHost, _tsLS: ts.LanguageService, config: PluginConfig, _logger: Logger);
+    get logger(): Logger;
+    get tsLS(): ts.LanguageService;
+    getConfigOptions(): CompilerOptions;
+}

package/dist/language-service/ns-language-service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NsLanguageService = void 0;
+function parseNsCompilerOptions(config) {
+    return {
+        debug: false,
+        logPath: "./nexus-ioc-plugin.log",
+        ...config,
+    };
+}
+class NsLanguageService {
+    constructor(project, host, _tsLS, config, _logger) {
+        this.project = project;
+        this.host = host;
+        this._tsLS = _tsLS;
+        this.config = config;
+        this._logger = _logger;
+        this.options = parseNsCompilerOptions(config);
+        const projectName = project.getProjectName();
+        _logger.log(`Nexus-IoC compiler options for ${projectName}: ${JSON.stringify(this.options)}`);
+    }
+    get logger() {
+        return this._logger;
+    }
+    get tsLS() {
+        return this._tsLS;
+    }
+    getConfigOptions() {
+        return this.options;
+    }
+}
+exports.NsLanguageService = NsLanguageService;
+//# sourceMappingURL=ns-language-service.js.map

package/dist/language-service/ns-language-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ns-language-service.js","sourceRoot":"","sources":["../../src/language-service/ns-language-service.ts"],"names":[],"mappings":";;;AAIA,SAAS,sBAAsB,CAAC,MAAoB;IACnD,OAAO;QACN,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,wBAAwB;QACjC,GAAG,MAAM;KACT,CAAC;AACH,CAAC;AAOD,MAAa,iBAAiB;IAG7B,YACkB,OAA0B,EAC1B,IAA0B,EAC1B,KAAyB,EACzB,MAAoB,EACpB,OAAe;QAJf,YAAO,GAAP,OAAO,CAAmB;QAC1B,SAAI,GAAJ,IAAI,CAAsB;QAC1B,UAAK,GAAL,KAAK,CAAoB;QACzB,WAAM,GAAN,MAAM,CAAc;QACpB,YAAO,GAAP,OAAO,CAAQ;QAEhC,IAAI,CAAC,OAAO,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;QAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;QAE7C,OAAO,CAAC,GAAG,CACV,kCAAkC,WAAW,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAChF,CAAC;IACH,CAAC;IAED,IAAI,MAAM;QACT,OAAO,IAAI,CAAC,OAAO,CAAC;IACrB,CAAC;IAED,IAAI,IAAI;QACP,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAEM,gBAAgB;QACtB,OAAO,IAAI,CAAC,OAAO,CAAC;IACrB,CAAC;CACD;AA7BD,8CA6BC"}

package/dist/language-service/parse-config-service.d.ts

@@ -0,0 +1,22 @@
+import type ts from "typescript";
+import type { AbsoluteFsPath, ConfigurationHost, FileStats, PathSegment, PathString } from "./types";
+/**
+ * Used to read configuration files.
+ *
+ * A language service parse configuration host is independent of the adapter
+ * because signatures of calls like `FileSystem#readFile` are a bit stricter
+ * than those on the adapter.
+ */
+export declare class ParseConfigHost implements ConfigurationHost {
+    private readonly serverHost;
+    constructor(serverHost: ts.server.ServerHost);
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    lstat(path: AbsoluteFsPath): FileStats;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    pwd(): AbsoluteFsPath;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    resolve(...paths: string[]): AbsoluteFsPath;
+    dirname<T extends PathString>(file: T): T;
+    join<T extends PathString>(basePath: T, ...paths: string[]): T;
+}

package/dist/language-service/parse-config-service.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseConfigHost = void 0;
+const tslib_1 = require("tslib");
+const p = tslib_1.__importStar(require("node:path"));
+/**
+ * Used to read configuration files.
+ *
+ * A language service parse configuration host is independent of the adapter
+ * because signatures of calls like `FileSystem#readFile` are a bit stricter
+ * than those on the adapter.
+ */
+class ParseConfigHost {
+    constructor(serverHost) {
+        this.serverHost = serverHost;
+    }
+    exists(path) {
+        return (this.serverHost.fileExists(path) || this.serverHost.directoryExists(path));
+    }
+    readFile(path) {
+        const content = this.serverHost.readFile(path);
+        if (content === undefined) {
+            throw new Error(`LanguageServiceFS#readFile called on unavailable file ${path}`);
+        }
+        return content;
+    }
+    lstat(path) {
+        return {
+            isFile: () => {
+                return this.serverHost.fileExists(path);
+            },
+            isDirectory: () => {
+                return this.serverHost.directoryExists(path);
+            },
+            isSymbolicLink: () => {
+                throw new Error("LanguageServiceFS#lstat#isSymbolicLink not implemented");
+            },
+        };
+    }
+    readdir(path) {
+        return this.serverHost.readDirectory(path, undefined, undefined, undefined, 
+        /* depth */ 1);
+    }
+    pwd() {
+        return this.serverHost.getCurrentDirectory();
+    }
+    extname(path) {
+        return p.extname(path);
+    }
+    resolve(...paths) {
+        return p.resolve(...paths);
+    }
+    dirname(file) {
+        return p.dirname(file);
+    }
+    join(basePath, ...paths) {
+        return p.join(basePath, ...paths);
+    }
+}
+exports.ParseConfigHost = ParseConfigHost;
+//# sourceMappingURL=parse-config-service.js.map

package/dist/language-service/parse-config-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-config-service.js","sourceRoot":"","sources":["../../src/language-service/parse-config-service.ts"],"names":[],"mappings":";;;;AAAA,qDAA+B;AAU/B;;;;;;GAMG;AACH,MAAa,eAAe;IAC3B,YAA6B,UAAgC;QAAhC,eAAU,GAAV,UAAU,CAAsB;IAAG,CAAC;IAEjE,MAAM,CAAC,IAAoB;QAC1B,OAAO,CACN,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,CACzE,CAAC;IACH,CAAC;IACD,QAAQ,CAAC,IAAoB;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CACd,yDAAyD,IAAI,EAAE,CAC/D,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC;IAChB,CAAC;IACD,KAAK,CAAC,IAAoB;QACzB,OAAO;YACN,MAAM,EAAE,GAAG,EAAE;gBACZ,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YACD,WAAW,EAAE,GAAG,EAAE;gBACjB,OAAO,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAC9C,CAAC;YACD,cAAc,EAAE,GAAG,EAAE;gBACpB,MAAM,IAAI,KAAK,CACd,wDAAwD,CACxD,CAAC;YACH,CAAC;SACD,CAAC;IACH,CAAC;IAED,OAAO,CAAC,IAAoB;QAC3B,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CACnC,IAAI,EACJ,SAAS,EACT,SAAS,EACT,SAAS;QACT,WAAW,CAAC,CAAC,CACI,CAAC;IACpB,CAAC;IAED,GAAG;QACF,OAAO,IAAI,CAAC,UAAU,CAAC,mBAAmB,EAAoB,CAAC;IAChE,CAAC;IAED,OAAO,CAAC,IAAkC;QACzC,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,CAAC,GAAG,KAAe;QACzB,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,KAAK,CAAmB,CAAC;IAC9C,CAAC;IAED,OAAO,CAAuB,IAAO;QACpC,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,CAAM,CAAC;IAC7B,CAAC;IAED,IAAI,CAAuB,QAAW,EAAE,GAAG,KAAe;QACzD,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,KAAK,CAAM,CAAC;IACxC,CAAC;CACD;AA9DD,0CA8DC"}

package/dist/language-service/types.d.ts

@@ -0,0 +1,88 @@
+export type PathString = string | AbsoluteFsPath | PathSegment;
+/**
+ * A `string` representing a specific type of path, with a particular brand `B`.
+ *
+ * A `string` is not assignable to a `BrandedPath`, but a `BrandedPath` is assignable to a `string`.
+ * Two `BrandedPath`s with different brands are not mutually assignable.
+ */
+export type BrandedPath<B extends string> = string & {
+    _brand: B;
+};
+/**
+ * A fully qualified path in the file system, in POSIX form.
+ */
+export type AbsoluteFsPath = BrandedPath<"AbsoluteFsPath">;
+/**
+ * A path that's relative to another (unspecified) root.
+ *
+ * This does not necessarily have to refer to a physical file.
+ */
+export type PathSegment = BrandedPath<"PathSegment">;
+/**
+ * An abstraction over the path manipulation aspects of a file-system.
+ */
+export interface PathManipulation {
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    isRoot(path: AbsoluteFsPath): boolean;
+    isRooted(path: string): boolean;
+    dirname<T extends PathString>(file: T): T;
+    extname(path: AbsoluteFsPath | PathSegment): string;
+    join<T extends PathString>(basePath: T, ...paths: string[]): T;
+    /**
+     * Compute the relative path between `from` and `to`.
+     *
+     * In file-systems that can have multiple file trees the returned path may not actually be
+     * "relative" (i.e. `PathSegment`). For example, Windows can have multiple drives :
+     * `relative('c:/a/b', 'd:/a/c')` would be `d:/a/c'.
+     */
+    relative<T extends PathString>(from: T, to: T): PathSegment | AbsoluteFsPath;
+    basename(filePath: string, extension?: string): PathSegment;
+    normalize<T extends PathString>(path: T): T;
+    resolve(...paths: string[]): AbsoluteFsPath;
+    pwd(): AbsoluteFsPath;
+    chdir(path: AbsoluteFsPath): void;
+}
+/**
+ * An abstraction over the read-only aspects of a file-system.
+ */
+export interface ReadonlyFileSystem extends PathManipulation {
+    isCaseSensitive(): boolean;
+    exists(path: AbsoluteFsPath): boolean;
+    readFile(path: AbsoluteFsPath): string;
+    readFileBuffer(path: AbsoluteFsPath): Uint8Array;
+    readdir(path: AbsoluteFsPath): PathSegment[];
+    lstat(path: AbsoluteFsPath): FileStats;
+    stat(path: AbsoluteFsPath): FileStats;
+    realpath(filePath: AbsoluteFsPath): AbsoluteFsPath;
+    getDefaultLibLocation(): AbsoluteFsPath;
+}
+/**
+ * A basic interface to abstract the underlying file-system.
+ *
+ * This makes it easier to provide mock file-systems in unit tests,
+ * but also to create clever file-systems that have features such as caching.
+ */
+export interface FileSystem extends ReadonlyFileSystem {
+    writeFile(path: AbsoluteFsPath, data: string | Uint8Array, exclusive?: boolean): void;
+    removeFile(path: AbsoluteFsPath): void;
+    symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
+    copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
+    ensureDir(path: AbsoluteFsPath): void;
+    removeDeep(path: AbsoluteFsPath): void;
+}
+/**
+ * Information about an object in the FileSystem.
+ * This is analogous to the `fs.Stats` class in Node.js.
+ */
+export interface FileStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+}
+/** Used to read configuration files. */
+export type ConfigurationHost = Pick<ReadonlyFileSystem, "readFile" | "exists" | "lstat" | "resolve" | "join" | "dirname" | "extname" | "pwd" | "readdir">;
+export type CompilerOptions = {
+    debug: boolean;
+    logPath: string;
+};

package/dist/language-service/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/language-service/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/language-service/types.ts"],"names":[],"mappings":""}

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+export declare class Logger {
+    private readonly options;
+    constructor(options: {
+        debug: boolean;
+        logPath: string;
+    });
+    log(message: string): void;
+}

package/dist/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("node:fs"));
+class Logger {
+    constructor(options) {
+        this.options = options;
+    }
+    log(message) {
+        if (!this.options.debug) {
+            return;
+        }
+        const logMessage = `${message}\n`;
+        fs.appendFileSync(this.options.logPath, logMessage, { encoding: "utf8" });
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":";;;;AAAA,oDAA8B;AAE9B,MAAa,MAAM;IAClB,YAA6B,OAA4C;QAA5C,YAAO,GAAP,OAAO,CAAqC;IAAG,CAAC;IAE7E,GAAG,CAAC,OAAe;QAClB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YACzB,OAAO;QACR,CAAC;QAED,MAAM,UAAU,GAAG,GAAG,OAAO,IAAI,CAAC;QAClC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3E,CAAC;CACD;AAXD,wBAWC"}

package/dist/parsers/inject.parser.d.ts

@@ -0,0 +1,16 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+import type { Logger } from "../logger";
+export type InjectParameterDeclaration = {
+    name: ts.Identifier | ts.StringLiteral;
+    location: "constructor" | "property";
+    declaration: ts.ParameterDeclaration;
+    start: number;
+    end: number;
+    length: number;
+    parameterName: string;
+    parameterType?: ts.TypeReferenceType | ts.Node;
+};
+export declare class InjectParser {
+    static execute(classDeclaration: ts.ClassDeclaration, logger: Logger): InjectParameterDeclaration[];
+    private static getParameterTypeNode;
+}

package/dist/parsers/inject.parser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectParser = void 0;
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
+class InjectParser {
+    static execute(classDeclaration, logger) {
+        const params = [];
+        logger.log(`[InjectParser][execute] ${classDeclaration.getText()}`);
+        const injectConstructorParams = tsquery_1.tsquery.query(classDeclaration, `Constructor > Parameter:has(Decorator > CallExpression > Identifier[name="Inject"])`);
+        for (const injectConstructorParam of injectConstructorParams) {
+            const [dependencyStringName] = tsquery_1.tsquery.query(injectConstructorParam, "Decorator > CallExpression StringLiteral") || [];
+            const [dependencyLink] = tsquery_1.tsquery.query(injectConstructorParam, "Decorator > CallExpression Identifier:not([name='Inject'])") || [];
+            const dependencyName = dependencyStringName || dependencyLink;
+            if (!dependencyName) {
+                continue;
+            }
+            const start = injectConstructorParam.getStart();
+            const end = injectConstructorParam.getEnd();
+            const parameterName = injectConstructorParam.name.getText();
+            const parameterType = InjectParser.getParameterTypeNode(injectConstructorParam);
+            params.push({
+                name: dependencyName,
+                location: "constructor",
+                declaration: injectConstructorParam,
+                start,
+                end,
+                length: end - start,
+                parameterName,
+                parameterType,
+            });
+        }
+        // const injectPropertyParams = tsquery.query<ts.PropertyDeclaration>(
+        // 	classDeclaration,
+        // 	selectorInjectProperty,
+        // );
+        return params;
+    }
+    static getParameterTypeNode(param) {
+        return param.type;
+    }
+}
+exports.InjectParser = InjectParser;
+//# sourceMappingURL=inject.parser.js.map

package/dist/parsers/inject.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.parser.js","sourceRoot":"","sources":["../../src/parsers/inject.parser.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AAepD,gEAAgE;AAChE,MAAa,YAAY;IACjB,MAAM,CAAC,OAAO,CAAC,gBAAqC,EAAE,MAAc;QAC1E,MAAM,MAAM,GAAiC,EAAE,CAAC;QAChD,MAAM,CAAC,GAAG,CAAC,2BAA2B,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,iBAAO,CAAC,KAAK,CAC5C,gBAAgB,EAChB,qFAAqF,CACrF,CAAC;QAEF,KAAK,MAAM,sBAAsB,IAAI,uBAAuB,EAAE,CAAC;YAC9D,MAAM,CAAC,oBAAoB,CAAC,GAC3B,iBAAO,CAAC,KAAK,CACZ,sBAAsB,EACtB,0CAA0C,CAC1C,IAAI,EAAE,CAAC;YACT,MAAM,CAAC,cAAc,CAAC,GACrB,iBAAO,CAAC,KAAK,CACZ,sBAAsB,EACtB,4DAA4D,CAC5D,IAAI,EAAE,CAAC;YAET,MAAM,cAAc,GAAG,oBAAoB,IAAI,cAAc,CAAC;YAE9D,IAAI,CAAC,cAAc,EAAE,CAAC;gBACrB,SAAS;YACV,CAAC;YAED,MAAM,KAAK,GAAG,sBAAsB,CAAC,QAAQ,EAAE,CAAC;YAChD,MAAM,GAAG,GAAG,sBAAsB,CAAC,MAAM,EAAE,CAAC;YAC5C,MAAM,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5D,MAAM,aAAa,GAAG,YAAY,CAAC,oBAAoB,CACtD,sBAAsB,CACtB,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC;gBACX,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,aAAa;gBACvB,WAAW,EAAE,sBAAsB;gBACnC,KAAK;gBACL,GAAG;gBACH,MAAM,EAAE,GAAG,GAAG,KAAK;gBACnB,aAAa;gBACb,aAAa;aACb,CAAC,CAAC;QACJ,CAAC;QAED,sEAAsE;QACtE,qBAAqB;QACrB,2BAA2B;QAC3B,KAAK;QAEL,OAAO,MAAM,CAAC;IACf,CAAC;IAEO,MAAM,CAAC,oBAAoB,CAAC,KAA8B;QACjE,OAAO,KAAK,CAAC,IAAI,CAAC;IACnB,CAAC;CACD;AAzDD,oCAyDC"}

package/dist/parsers/injectable.parser.d.ts

@@ -0,0 +1,5 @@
+import { type SourceFile } from "@phenomnomnominal/tsquery";
+import type ts from "typescript/lib/tsserverlibrary";
+export declare class InjectableParser {
+    static execute(sourceFile: SourceFile): ts.ClassDeclaration[];
+}

package/dist/parsers/injectable.parser.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectableParser = void 0;
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const selector = `ClassDeclaration:has(Decorator > CallExpression > Identifier[name="Injectable"])`;
+// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
+class InjectableParser {
+    static execute(sourceFile) {
+        return tsquery_1.tsquery.query(sourceFile, selector);
+    }
+}
+exports.InjectableParser = InjectableParser;
+//# sourceMappingURL=injectable.parser.js.map

package/dist/parsers/injectable.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable.parser.js","sourceRoot":"","sources":["../../src/parsers/injectable.parser.ts"],"names":[],"mappings":";;;AAAA,uDAAqE;AAGrE,MAAM,QAAQ,GAAG,kFAAkF,CAAC;AAEpG,gEAAgE;AAChE,MAAa,gBAAgB;IACrB,MAAM,CAAC,OAAO,CAAC,UAAsB;QAC3C,OAAO,iBAAO,CAAC,KAAK,CAAsB,UAAU,EAAE,QAAQ,CAAC,CAAC;IACjE,CAAC;CACD;AAJD,4CAIC"}

package/dist/parsers/ns-module.parser.d.ts

@@ -0,0 +1,45 @@
+import * as ts from "typescript/lib/tsserverlibrary";
+import type { Logger } from "../logger";
+export type ProviderType = {
+    provide: ts.Expression | ts.StringLiteral;
+    provideType: "class" | "useClass" | "useValue" | "useFactory";
+    declaration: ts.Expression | ts.Identifier;
+    start: number;
+    end: number;
+    length: number;
+};
+export type ImportType = {
+    importType: "local" | "feature" | "global";
+    declaration: ts.Expression;
+    start: number;
+    end: number;
+    length: number;
+};
+export type ExportType = {
+    name?: string;
+    scope: "internal" | "external";
+    declaration: ts.Identifier | ts.StringLiteral;
+    start: number;
+    end: number;
+    length: number;
+    illegal: boolean;
+};
+export type NsModuleDeclaration = {
+    moduleName: string;
+    providers: ProviderType[];
+    imports: ImportType[];
+    exports: ExportType[];
+    start: number;
+    end: number;
+    length: number;
+    sourceFile: ts.SourceFile;
+};
+export declare class NsModuleParser {
+    static execute(modules: ts.ClassDeclaration[], typeChecker: ts.TypeChecker, logger: Logger): NsModuleDeclaration[];
+    private static getNsModuleName;
+    private static getNsModuleDecoratorValue;
+    private static parseImports;
+    private static parseExports;
+    private static parseProviders;
+    private static parseUseProvider;
+}

package/dist/parsers/ns-module.parser.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NsModuleParser = void 0;
+const tslib_1 = require("tslib");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = tslib_1.__importStar(require("typescript/lib/tsserverlibrary"));
+const findPropertyInObject = (obj, key) => obj.properties.find((property) => {
+    return obj.properties.find((property) => {
+        if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+            return property.name.text === key;
+        }
+        if (ts.isMethodDeclaration(property) && ts.isIdentifier(property.name)) {
+            return property.name.text === key;
+        }
+        return false;
+    });
+});
+// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
+class NsModuleParser {
+    static execute(modules, typeChecker, logger) {
+        const result = [];
+        for (const module of modules) {
+            const moduleName = NsModuleParser.getNsModuleName(module);
+            if (!NsModuleParser) {
+                continue;
+            }
+            const start = module.getStart();
+            const end = module.getEnd();
+            const length = end - start;
+            const { providers, imports, exports } = NsModuleParser.getNsModuleDecoratorValue(module, typeChecker, logger);
+            const sourceFile = module.getSourceFile();
+            result.push({
+                moduleName,
+                providers,
+                imports,
+                exports,
+                start,
+                end,
+                length,
+                sourceFile,
+            });
+        }
+        return result;
+    }
+    static getNsModuleName(classDeclaration) {
+        return classDeclaration.name?.getText();
+    }
+    static getNsModuleDecoratorValue(classDeclaration, typeChecker, logger) {
+        const [decoratorValue] = tsquery_1.tsquery.query(classDeclaration, `CallExpression:has(Identifier[name="NsModule"]) > ObjectLiteralExpression`) || [];
+        const providersRaw = decoratorValue.properties.find((item) => item.name?.getText() === "providers");
+        const importsRaw = decoratorValue.properties.find((item) => item.name?.getText() === "imports");
+        const exportsRaw = decoratorValue.properties.find((item) => item.name?.getText() === "exports");
+        const providers = providersRaw?.initializer
+            ? NsModuleParser.parseProviders(providersRaw.initializer, logger)
+            : [];
+        const imports = importsRaw?.initializer
+            ? NsModuleParser.parseImports(importsRaw.initializer, logger)
+            : [];
+        const exports = exportsRaw?.initializer
+            ? NsModuleParser.parseExports(exportsRaw.initializer, providers, typeChecker, logger)
+            : [];
+        return {
+            imports,
+            exports,
+            providers,
+        };
+    }
+    static parseImports(imports, logger) {
+        const result = [];
+        imports.forEachChild((child) => {
+            if (ts.isIdentifier(child) || ts.isCallExpression(child)) {
+                const start = child.getStart();
+                const end = child.getEnd();
+                const length = end - start;
+                let importType = null;
+                let type = ts.isIdentifier(child) ? child : null;
+                if (ts.isIdentifier(child)) {
+                    importType = "local";
+                }
+                else if (ts.isCallExpression(child)) {
+                    const [typeNode] = (0, tsquery_1.tsquery)(child, "PropertyAccessExpression Identifier");
+                    type = typeNode;
+                    const isFeature = Boolean((0, tsquery_1.tsquery)(child, `PropertyAccessExpression Identifier[name="forFeature"]`)?.length);
+                    const isRoot = Boolean((0, tsquery_1.tsquery)(child, `PropertyAccessExpression Identifier[name="forRoot"]`)?.length);
+                    if (isFeature) {
+                        importType = "feature";
+                    }
+                    else if (isRoot) {
+                        importType = "global";
+                    }
+                }
+                if (!importType || !type) {
+                    return;
+                }
+                result.push({
+                    importType,
+                    start,
+                    end,
+                    length,
+                    declaration: type,
+                });
+                return;
+            }
+        });
+        return result;
+    }
+    static parseExports(exports, providers, typeChecker, logger) {
+        const result = [];
+        exports.forEachChild((child) => {
+            if (ts.isIdentifier(child)) {
+                const type = child;
+                const start = child.getStart();
+                const end = child.getEnd();
+                const length = end - start;
+                let importType = "external";
+                for (const provider of providers) {
+                    const type1 = typeChecker.getTypeAtLocation(provider.declaration);
+                    const type2 = typeChecker.getTypeAtLocation(type);
+                    if (typeChecker.isTypeAssignableTo(type1, type2) &&
+                        typeChecker.isTypeAssignableTo(type2, type1)) {
+                        importType = "internal";
+                    }
+                }
+                result.push({
+                    scope: importType,
+                    declaration: type,
+                    start,
+                    end,
+                    length,
+                    illegal: false,
+                });
+                return;
+            }
+            if (ts.isStringLiteral(child)) {
+                const type = child;
+                const start = child.getStart();
+                const end = child.getEnd();
+                const length = end - start;
+                let depType = "external";
+                for (const provider of providers) {
+                    if (provider.provide?.getText() === type.text) {
+                        depType = "internal";
+                    }
+                }
+                result.push({
+                    name: type.getText(),
+                    scope: depType,
+                    start,
+                    end,
+                    length,
+                    declaration: type,
+                    illegal: depType === "external",
+                });
+                return;
+            }
+        });
+        return result;
+    }
+    static parseProviders(providers, logger) {
+        const result = [];
+        providers.forEachChild((child) => {
+            if (ts.isIdentifier(child)) {
+                const start = child.getStart();
+                const end = child.getEnd();
+                const length = end - start;
+                result.push({
+                    provide: child,
+                    provideType: "class",
+                    start,
+                    end,
+                    length,
+                    declaration: child,
+                });
+                return;
+            }
+            if (ts.isObjectLiteralExpression(child)) {
+                const provider = NsModuleParser.parseUseProvider(child, logger);
+                if (provider) {
+                    result.push(provider);
+                }
+                return;
+            }
+        });
+        return result;
+    }
+    static parseUseProvider(provider, logger) {
+        const provideNameNode = findPropertyInObject(provider, "provide");
+        const provideUseClassNode = findPropertyInObject(provider, "useClass");
+        const provideUseValueNode = findPropertyInObject(provider, "useValue");
+        const provideUseFactoryNode = findPropertyInObject(provider, "useFactory");
+        const providerNode = provideUseClassNode || provideUseValueNode || provideUseFactoryNode;
+        if (!provideNameNode || !providerNode) {
+            return null;
+        }
+        let provide = null;
+        if (ts.isPropertyAssignment(provideNameNode) &&
+            ts.isStringLiteral(provideNameNode.initializer)) {
+            provide = provideNameNode.initializer;
+        }
+        else if (ts.isPropertyAssignment(provideNameNode) &&
+            ts.isExpression(provideNameNode.initializer)) {
+            provide = provideNameNode.initializer;
+        }
+        const providerTypeLink = ts.isPropertyAssignment(providerNode)
+            ? providerNode.initializer
+            : null;
+        if (!provide || !providerTypeLink) {
+            return null;
+        }
+        const start = provideNameNode.getStart();
+        const end = provideNameNode.getEnd();
+        const length = end - start;
+        let provideType = null;
+        if (provideUseClassNode) {
+            provideType = "useClass";
+        }
+        else if (provideUseValueNode) {
+            provideType = "useValue";
+        }
+        else if (provideUseFactoryNode) {
+            provideType = "useFactory";
+        }
+        if (!provideType) {
+            return null;
+        }
+        return {
+            provide,
+            provideType,
+            declaration: providerTypeLink,
+            start,
+            end,
+            length,
+        };
+    }
+}
+exports.NsModuleParser = NsModuleParser;
+//# sourceMappingURL=ns-module.parser.js.map