@dotglitch/ngx-common 1.0.21 → 1.0.22

package/esm2020/components/vscode/ts-type-resolver/import-resolver.mjs

@@ -0,0 +1,311 @@
+import { DependencyParser } from './dependency-parser';
+import * as path from 'path-browserify';
+import { invokeUpdate } from './update-emitter';
+import { RecursionDepth } from './recursion-depth';
+import { importResourcePathToString } from './types';
+import { UnpkgSourceResolver } from './unpkg-source-resolver';
+export class ImportResolver {
+    constructor(options) {
+        this.options = options;
+        this.loadedFiles = [];
+        this.dependencyParser = new DependencyParser();
+        this.cache = options.sourceCache;
+        this.newImportsResolved = false;
+        this.monaco = options.monaco;
+        if (options.preloadPackages && options.versions) {
+            this.versions = options.versions;
+            for (const [packageName, version] of Object.entries(options.versions)) {
+                this.resolveImport({
+                    kind: 'package',
+                    packageName: packageName,
+                    importPath: '',
+                }, new RecursionDepth(this.options)).catch(e => {
+                    console.error(e);
+                });
+            }
+        }
+    }
+    wereNewImportsResolved() {
+        return this.newImportsResolved;
+    }
+    resetNewImportsResolved() {
+        this.newImportsResolved = false;
+    }
+    async resolveImportsInFile(source, parent, depth) {
+        if (depth.shouldStop()) {
+            return;
+        }
+        const imports = this.dependencyParser.parseDependencies(source, parent);
+        for (const importCall of imports) {
+            try {
+                await this.resolveImport(importCall, depth);
+            }
+            catch (e) {
+                if (this.options.onError) {
+                    this.options.onError?.(e.message ?? e);
+                }
+                else {
+                    console.error(e);
+                }
+            }
+        }
+    }
+    async resolveImport(importResource, depth) {
+        const hash = this.hashImportResourcePath(importResource);
+        if (this.loadedFiles.includes(hash)) {
+            return;
+        }
+        this.loadedFiles.push(hash);
+        console.log("resolveImport", importResource, depth);
+        // Ignore these package imports as they are well-known to be pointless.
+        if (importResource.kind == "package" && importResource.packageName == "require")
+            return null;
+        switch (importResource.kind) {
+            case 'package':
+                const packageRelativeImport = await this.resolveImportFromPackageRoot(importResource);
+                if (packageRelativeImport) {
+                    return await this.resolveImportInPackage(packageRelativeImport, depth.nextPackage().nextFile());
+                }
+                break;
+            case 'relative':
+                throw Error('Not implemented yet');
+            case 'relative-in-package':
+                return await this.resolveImportInPackage(importResource, depth.nextFile());
+            case 'bruteforce': {
+            }
+        }
+    }
+    async resolveImportInPackage(importResource, depth) {
+        console.log("resolveImportInPackage", importResource, depth);
+        const contents = await this.loadSourceFileContents(importResource);
+        if (contents) {
+            const { source, at } = contents;
+            this.createModel(source, this.monaco.Uri.parse(this.options.fileRootPath + path.join(`node_modules/${importResource.packageName}`, at)));
+            await this.resolveImportsInFile(source, {
+                kind: 'relative-in-package',
+                packageName: importResource.packageName,
+                sourcePath: path.dirname(at),
+                importPath: '',
+            }, depth);
+        }
+    }
+    async resolveImportFromPackageRoot(importResource) {
+        console.log("resolveImportFromPackageRoot", importResource);
+        const failedProgressUpdate = {
+            type: 'LookedUpPackage',
+            package: importResource.packageName,
+            definitelyTyped: false,
+            success: false,
+        };
+        if (this.options.onlySpecifiedPackages) {
+            if (!this.versions?.[importResource.packageName] && !this.versions?.['@types/' + importResource.packageName]) {
+                invokeUpdate(failedProgressUpdate, this.options);
+                return null;
+            }
+        }
+        const doesPkgJsonHasSubpath = importResource.importPath?.length ?? 0 > 0;
+        let pkgJsonSubpath = doesPkgJsonHasSubpath ? `/${importResource.importPath}` : '';
+        let pkgJson = await this.resolvePackageJson(importResource.packageName, this.versions?.[importResource.packageName], doesPkgJsonHasSubpath ? importResource.importPath : undefined);
+        if (!pkgJson && doesPkgJsonHasSubpath) {
+            pkgJson = await this.resolvePackageJson(importResource.packageName, this.versions?.[importResource.packageName]);
+            pkgJsonSubpath = '';
+        }
+        if (!pkgJson)
+            return invokeUpdate(failedProgressUpdate, this.options);
+        const pkg = JSON.parse(pkgJson);
+        console.log("package meta", pkg);
+        if (pkg.typings || pkg.types) {
+            const typings = pkg.typings || pkg.types;
+            this.createModel(pkgJson, this.monaco.Uri.parse(`${this.options.fileRootPath}node_modules/${importResource.packageName}${pkgJsonSubpath}/package.json`));
+            invokeUpdate({
+                type: 'LookedUpPackage',
+                package: importResource.packageName,
+                definitelyTyped: false,
+                success: true,
+            }, this.options);
+            this.setVersion(importResource.packageName, pkg.version);
+            return {
+                kind: 'relative-in-package',
+                packageName: importResource.packageName,
+                sourcePath: '',
+                importPath: path.join(importResource.importPath ?? '', typings.startsWith('./') ? typings.slice(2) : typings),
+            };
+        }
+        else {
+            const typingPackageName = `@types/${importResource.packageName.startsWith('@')
+                ? importResource.packageName.slice(1).replace(/\//, '__')
+                : importResource.packageName}`;
+            const pkgJsonTypings = await this.resolvePackageJson(typingPackageName, this.versions?.[typingPackageName]);
+            if (!pkgJsonTypings)
+                return invokeUpdate(failedProgressUpdate, this.options);
+            const pkg = JSON.parse(pkgJsonTypings);
+            if (!pkg.typings && !pkg.types) {
+                const files = await fetch("https://www.npmjs.com/package/@dt-esa/dynatrace-api-client/v/2.2.6/index", {
+                    method: "get"
+                }).then(e => e.json());
+                const typingFiles = Object.entries(files.files).map(([key, val]) => val);
+                invokeUpdate({
+                    type: 'LookedUpPackage',
+                    package: typingPackageName,
+                    definitelyTyped: true,
+                    success: true,
+                }, this.options);
+                return {
+                    kind: 'bruteforce',
+                    packageName: typingPackageName,
+                    typingFiles,
+                };
+                return;
+                // return invokeUpdate(failedProgressUpdate, this.options);
+            }
+            const typings = pkg.typings || pkg.types;
+            this.createModel(pkgJsonTypings, this.monaco.Uri.parse(`${this.options.fileRootPath}node_modules/${typingPackageName}/package.json`));
+            invokeUpdate({
+                type: 'LookedUpPackage',
+                package: typingPackageName,
+                definitelyTyped: true,
+                success: true,
+            }, this.options);
+            this.setVersion(typingPackageName, pkg.version);
+            return {
+                kind: 'relative-in-package',
+                packageName: typingPackageName,
+                sourcePath: '',
+                importPath: path.join(importResource.importPath ?? '', typings.startsWith('./') ? typings.slice(2) : typings),
+            };
+        }
+    }
+    async loadSourceFileContents(importResource) {
+        const progressUpdatePath = path.join(importResource.packageName, importResource.sourcePath, importResource.importPath);
+        const failedProgressUpdate = {
+            type: 'LookedUpTypeFile',
+            path: progressUpdatePath,
+            definitelyTyped: false,
+            success: false,
+        };
+        const pkgName = importResource.packageName;
+        const version = this.getVersion(importResource.packageName);
+        let appends = ['.d.ts', '/index.d.ts', '.ts', '.tsx', '/index.ts', '/index.tsx'];
+        if (appends.map(append => importResource.importPath.endsWith(append)).reduce((a, b) => a || b, false)) {
+            const source = await this.resolveSourceFile(pkgName, version, path.join(importResource.sourcePath, importResource.importPath));
+            if (source) {
+                return { source, at: path.join(importResource.sourcePath, importResource.importPath) };
+            }
+        }
+        else {
+            for (const append of appends) {
+                const fullPath = path.join(importResource.sourcePath, importResource.importPath) + append;
+                const source = await this.resolveSourceFile(pkgName, version, fullPath);
+                invokeUpdate({
+                    type: 'AttemptedLookUpFile',
+                    path: path.join(pkgName, fullPath),
+                    success: !!source,
+                }, this.options);
+                if (source) {
+                    invokeUpdate({
+                        type: 'LookedUpTypeFile',
+                        path: path.join(pkgName, fullPath),
+                        success: true,
+                    }, this.options);
+                    return { source, at: fullPath };
+                }
+            }
+        }
+        const pkgJson = await this.resolvePackageJson(pkgName, version, path.join(importResource.sourcePath, importResource.importPath));
+        if (pkgJson) {
+            const { types } = JSON.parse(pkgJson);
+            if (types) {
+                const fullPath = path.join(importResource.sourcePath, importResource.importPath, types);
+                const source = await this.resolveSourceFile(pkgName, version, fullPath);
+                if (source) {
+                    invokeUpdate({
+                        type: 'LookedUpTypeFile',
+                        path: path.join(pkgName, fullPath),
+                        success: true,
+                    }, this.options);
+                    return { source, at: fullPath };
+                }
+            }
+        }
+        invokeUpdate(failedProgressUpdate, this.options);
+        return null;
+    }
+    getVersion(packageName) {
+        return this.versions?.[packageName];
+    }
+    setVersions(versions) {
+        this.versions = versions;
+        this.options.onUpdateVersions?.(versions);
+        // TODO reload packages whose version has changed
+    }
+    setVersion(packageName, version) {
+        this.setVersions({
+            ...this.versions,
+            [packageName]: version,
+        });
+    }
+    createModel(source, uri) {
+        uri = uri.with({ path: uri.path.replace('@types/', '') });
+        if (!this.monaco.editor.getModel(uri)) {
+            this.monaco.editor.createModel(source, 'typescript', uri);
+            this.newImportsResolved = true;
+        }
+    }
+    hashImportResourcePath(p) {
+        return importResourcePathToString(p);
+    }
+    async resolvePackageJson(packageName, version, subPath) {
+        const uri = path.join(packageName + (version ? `@${version}` : ''), subPath ?? '', 'package.json');
+        let isAvailable = false;
+        let content = undefined;
+        if (this.cache.isFileAvailable) {
+            isAvailable = await this.cache.isFileAvailable(uri);
+        }
+        else {
+            content = await this.cache.getFile(uri);
+            isAvailable = content !== undefined;
+        }
+        if (isAvailable) {
+            return content ?? (await this.cache.getFile(uri));
+        }
+        else {
+            console.log("recursing resolvePackageJson", packageName, version, subPath);
+            content = await UnpkgSourceResolver.resolvePackageJson(packageName, version, subPath);
+            if (content) {
+                this.cache.storeFile(uri, content);
+            }
+            return content;
+        }
+    }
+    async resolveSourceFile(packageName, version, filePath) {
+        const uri = path.join(packageName + (version ? `@${version}` : ''), filePath);
+        let isAvailable = false;
+        let content = undefined;
+        if (this.cache.isFileAvailable) {
+            isAvailable = await this.cache.isFileAvailable(uri);
+        }
+        else {
+            content = await this.cache.getFile(uri);
+            isAvailable = content !== undefined;
+        }
+        if (isAvailable) {
+            invokeUpdate({
+                type: 'LoadedFromCache',
+                importPath: uri,
+            }, this.options);
+            return content ?? (await this.cache.getFile(uri));
+        }
+        else {
+            content = await UnpkgSourceResolver.resolveSourceFile(packageName, version, filePath);
+            if (content) {
+                invokeUpdate({
+                    type: 'StoredToCache',
+                    importPath: uri,
+                }, this.options);
+                this.cache.storeFile(uri, content);
+            }
+            return content;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import-resolver.js","sourceRoot":"","sources":["../../../../../../packages/common/src/components/vscode/ts-type-resolver/import-resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAA4G,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAC/J,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,MAAM,OAAO,cAAc;IAQvB,YAAoB,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;QAChC,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QACtB,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC;QAC/C,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC;QACjC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAO,CAAC;QAE9B,IAAI,OAAO,CAAC,eAAe,IAAI,OAAO,CAAC,QAAQ,EAAE;YAC7C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;YACjC,KAAK,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACnE,IAAI,CAAC,aAAa,CACd;oBACI,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,WAAW;oBACxB,UAAU,EAAE,EAAE;iBACjB,EACD,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CACnC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;oBACR,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACrB,CAAC,CAAC,CAAC;aACN;SACJ;IACL,CAAC;IAEM,sBAAsB;QACzB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACnC,CAAC;IAEM,uBAAuB;QAC1B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,MAAc,EAAE,MAAmC,EAAE,KAAqB;QACxG,IAAI,KAAK,CAAC,UAAU,EAAE,EAAE;YACpB,OAAO;SACV;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACxE,KAAK,MAAM,UAAU,IAAI,OAAO,EAAE;YAC9B,IAAI;gBACA,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;aAC/C;YACD,OAAO,CAAC,EAAE;gBACN,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;oBACtB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAE,CAAW,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;iBACrD;qBACI;oBACD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;iBACpB;aACJ;SACJ;IACL,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,cAAkC,EAAE,KAAqB;QACjF,MAAM,IAAI,GAAG,IAAI,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC;QACzD,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;YACjC,OAAO;SACV;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5B,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;QAEpD,uEAAuE;QACvE,IAAI,cAAc,CAAC,IAAI,IAAI,SAAS,IAAI,cAAc,CAAC,WAAW,IAAI,SAAS;YAC3E,OAAO,IAAI,CAAC;QAEhB,QAAQ,cAAc,CAAC,IAAI,EAAE;YACzB,KAAK,SAAS;gBACV,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,CAAC;gBACtF,IAAI,qBAAqB,EAAE;oBACvB,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;iBACnG;gBACD,MAAM;YACV,KAAK,UAAU;gBACX,MAAM,KAAK,CAAC,qBAAqB,CAAC,CAAC;YACvC,KAAK,qBAAqB;gBACtB,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC/E,KAAK,YAAY,CAAC,CAAC;aAElB;SACJ;IACL,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAAC,cAAmD,EAAE,KAAqB;QAC3G,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;QAE7D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC;QAEnE,IAAI,QAAQ,EAAE;YACV,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC;YAChC,IAAI,CAAC,WAAW,CACZ,MAAM,EACN,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,cAAc,CAAC,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,CACjH,CAAC;YAEF,MAAM,IAAI,CAAC,oBAAoB,CAC3B,MAAM,EACN;gBACI,IAAI,EAAE,qBAAqB;gBAC3B,WAAW,EAAE,cAAc,CAAC,WAAW;gBACvC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC5B,UAAU,EAAE,EAAE;aACjB,EACD,KAAK,CACR,CAAC;SACL;IACL,CAAC;IAEO,KAAK,CAAC,4BAA4B,CACtC,cAAyC;QAEzC,OAAO,CAAC,GAAG,CAAC,8BAA8B,EAAE,cAAc,CAAC,CAAC;QAE5D,MAAM,oBAAoB,GAAG;YACzB,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,cAAc,CAAC,WAAW;YACnC,eAAe,EAAE,KAAK;YACtB,OAAO,EAAE,KAAK;SACR,CAAC;QAEX,IAAI,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE;YACpC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,GAAG,cAAc,CAAC,WAAW,CAAC,EAAE;gBAC1G,YAAY,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBACjD,OAAO,IAAI,CAAC;aACf;SACJ;QAED,MAAM,qBAAqB,GAAG,cAAc,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC;QACzE,IAAI,cAAc,GAAG,qBAAqB,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,IAAI,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CACvC,cAAc,CAAC,WAAW,EAC1B,IAAI,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,WAAW,CAAC,EAC3C,qBAAqB,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAChE,CAAC;QAEF,IAAI,CAAC,OAAO,IAAI,qBAAqB,EAAE;YACnC,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC;YACjH,cAAc,GAAG,EAAE,CAAC;SACvB;QAED,IAAI,CAAC,OAAO;YAAE,OAAO,YAAY,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAEtE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEhC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;QAEjC,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE;YAC1B,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC;YACzC,IAAI,CAAC,WAAW,CACZ,OAAO,EACP,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CACjB,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,gBAAgB,cAAc,CAAC,WAAW,GAAG,cAAc,eAAe,CACzG,CACJ,CAAC;YAEF,YAAY,CACR;gBACI,IAAI,EAAE,iBAAiB;gBACvB,OAAO,EAAE,cAAc,CAAC,WAAW;gBACnC,eAAe,EAAE,KAAK;gBACtB,OAAO,EAAE,IAAI;aAChB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;YACF,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,WAAW,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAEzD,OAAO;gBACH,IAAI,EAAE,qBAAqB;gBAC3B,WAAW,EAAE,cAAc,CAAC,WAAW;gBACvC,UAAU,EAAE,EAAE;gBACd,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,IAAI,EAAE,EAAE,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;aAChH,CAAC;SACL;aACI;YAED,MAAM,iBAAiB,GAAG,UACtB,cAAc,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC;gBACtC,CAAC,CAAC,cAAc,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC;gBACzD,CAAC,CAAC,cAAc,CAAC,WACzB,EAAE,CAAC;YAEH,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAE5G,IAAI,CAAC,cAAc;gBACf,OAAO,YAAY,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YAE5D,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YAEvC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE;gBAC5B,MAAM,KAAK,GAeP,MAAM,KAAK,CAAC,0EAA0E,EAAE;oBACxF,MAAM,EAAE,KAAK;iBAChB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;gBAEvB,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;gBAEzE,YAAY,CACR;oBACI,IAAI,EAAE,iBAAiB;oBACvB,OAAO,EAAE,iBAAiB;oBAC1B,eAAe,EAAE,IAAI;oBACrB,OAAO,EAAE,IAAI;iBAChB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;gBAEF,OAAO;oBACH,IAAI,EAAE,YAAY;oBAClB,WAAW,EAAE,iBAAiB;oBAC9B,WAAW;iBACP,CAAC;gBAET,OAAO;gBACP,2DAA2D;aAC9D;YAED,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC;YACzC,IAAI,CAAC,WAAW,CACZ,cAAc,EACd,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,gBAAgB,iBAAiB,eAAe,CAAC,CACtG,CAAC;YAEF,YAAY,CACR;gBACI,IAAI,EAAE,iBAAiB;gBACvB,OAAO,EAAE,iBAAiB;gBAC1B,eAAe,EAAE,IAAI;gBACrB,OAAO,EAAE,IAAI;aAChB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;YACF,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAEhD,OAAO;gBACH,IAAI,EAAE,qBAAqB;gBAC3B,WAAW,EAAE,iBAAiB;gBAC9B,UAAU,EAAE,EAAE;gBACd,UAAU,EAAE,IAAI,CAAC,IAAI,CACjB,cAAc,CAAC,UAAU,IAAI,EAAE,EAC/B,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CACxD;aACJ,CAAC;SACL;IACL,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAChC,cAAmD;QAEnD,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAChC,cAAc,CAAC,WAAW,EAC1B,cAAc,CAAC,UAAU,EACzB,cAAc,CAAC,UAAU,CAC5B,CAAC;QAEF,MAAM,oBAAoB,GAAG;YACzB,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAkB;YACxB,eAAe,EAAE,KAAK;YACtB,OAAO,EAAE,KAAK;SACR,CAAC;QAEX,MAAM,OAAO,GAAG,cAAc,CAAC,WAAW,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAE5D,IAAI,OAAO,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QAEjF,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,EAAE;YACnG,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,iBAAiB,CACvC,OAAO,EACP,OAAO,EACP,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC,CAClE,CAAC;YACF,IAAI,MAAM,EAAE;gBACR,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC;aAC1F;SACJ;aACI;YACD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;gBAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC;gBAC1F,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;gBACxE,YAAY,CACR;oBACI,IAAI,EAAE,qBAAqB;oBAC3B,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;oBAClC,OAAO,EAAE,CAAC,CAAC,MAAM;iBACpB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;gBACF,IAAI,MAAM,EAAE;oBACR,YAAY,CACR;wBACI,IAAI,EAAE,kBAAkB;wBACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;wBAClC,OAAO,EAAE,IAAI;qBAChB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;oBACF,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;iBACnC;aACJ;SACJ;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CACzC,OAAO,EACP,OAAO,EACP,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC,CAClE,CAAC;QAEF,IAAI,OAAO,EAAE;YACT,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACtC,IAAI,KAAK,EAAE;gBACP,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;gBACxF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;gBACxE,IAAI,MAAM,EAAE;oBACR,YAAY,CACR;wBACI,IAAI,EAAE,kBAAkB;wBACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;wBAClC,OAAO,EAAE,IAAI;qBAChB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;oBACF,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;iBACnC;aACJ;SACJ;QAED,YAAY,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACjD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,UAAU,CAAC,WAAmB;QAClC,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC;IAEM,WAAW,CAAC,QAA2C;QAC1D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,CAAC;QAC1C,iDAAiD;IACrD,CAAC;IAEO,UAAU,CAAC,WAAmB,EAAE,OAAe;QACnD,IAAI,CAAC,WAAW,CAAC;YACb,GAAG,IAAI,CAAC,QAAQ;YAChB,CAAC,WAAW,CAAC,EAAE,OAAO;SACzB,CAAC,CAAC;IACP,CAAC;IAEO,WAAW,CAAC,MAAc,EAAE,GAAe;QAC/C,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACnC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,CAAC,CAAC;YAC1D,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;SAClC;IACL,CAAC;IAEO,sBAAsB,CAAC,CAAqB;QAChD,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAC5B,WAAmB,EACnB,OAAgB,EAChB,OAAgB;QAGhB,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC;QACnG,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,OAAO,GAAuB,SAAS,CAAC;QAE5C,IAAI,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE;YAC5B,WAAW,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;SACvD;aACI;YACD,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACxC,WAAW,GAAG,OAAO,KAAK,SAAS,CAAC;SACvC;QAED,IAAI,WAAW,EAAE;YACb,OAAO,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;SACrD;aACI;YACD,OAAO,CAAC,GAAG,CAAC,8BAA8B,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;YAC1E,OAAO,GAAG,MAAM,mBAAmB,CAAC,kBAAkB,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YACtF,IAAI,OAAO,EAAE;gBACT,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;aACtC;YACD,OAAO,OAAO,CAAC;SAClB;IACL,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC3B,WAAmB,EACnB,OAA2B,EAC3B,QAAgB;QAGhB,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC9E,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,OAAO,GAAuB,SAAS,CAAC;QAE5C,IAAI,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE;YAC5B,WAAW,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;SACvD;aACI;YACD,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACxC,WAAW,GAAG,OAAO,KAAK,SAAS,CAAC;SACvC;QAED,IAAI,WAAW,EAAE;YACb,YAAY,CACR;gBACI,IAAI,EAAE,iBAAiB;gBACvB,UAAU,EAAE,GAAG;aAClB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;YACF,OAAO,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;SACrD;aACI;YACD,OAAO,GAAG,MAAM,mBAAmB,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YACtF,IAAI,OAAO,EAAE;gBACT,YAAY,CACR;oBACI,IAAI,EAAE,eAAe;oBACrB,UAAU,EAAE,GAAG;iBAClB,EACD,IAAI,CAAC,OAAO,CACf,CAAC;gBACF,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;aACtC;YACD,OAAO,OAAO,CAAC;SAClB;IACL,CAAC;CACJ","sourcesContent":["import type * as monaco from 'monaco-editor';\nimport { DependencyParser } from './dependency-parser';\nimport * as path from 'path-browserify';\nimport { invokeUpdate } from './update-emitter';\nimport { RecursionDepth } from './recursion-depth';\nimport { ImportResourcePath, ImportResourcePathPackage, ImportResourcePathRelativeInPackage, Options, SourceCache, importResourcePathToString } from './types';\nimport { UnpkgSourceResolver } from './unpkg-source-resolver';\n\nexport class ImportResolver {\n    private loadedFiles: string[];\n    private dependencyParser: DependencyParser;\n    private cache: SourceCache;\n    private versions?: { [packageName: string]: string };\n    private newImportsResolved: boolean;\n    private monaco: typeof monaco;\n\n    constructor(private options: Options) {\n        this.loadedFiles = [];\n        this.dependencyParser = new DependencyParser();\n        this.cache = options.sourceCache;\n        this.newImportsResolved = false;\n        this.monaco = options.monaco!;\n\n        if (options.preloadPackages && options.versions) {\n            this.versions = options.versions;\n            for (const [packageName, version] of Object.entries(options.versions)) {\n                this.resolveImport(\n                    {\n                        kind: 'package',\n                        packageName: packageName,\n                        importPath: '',\n                    },\n                    new RecursionDepth(this.options)\n                ).catch(e => {\n                    console.error(e);\n                });\n            }\n        }\n    }\n\n    public wereNewImportsResolved() {\n        return this.newImportsResolved;\n    }\n\n    public resetNewImportsResolved() {\n        this.newImportsResolved = false;\n    }\n\n    public async resolveImportsInFile(source: string, parent: string | ImportResourcePath, depth: RecursionDepth) {\n        if (depth.shouldStop()) {\n            return;\n        }\n\n        const imports = this.dependencyParser.parseDependencies(source, parent);\n        for (const importCall of imports) {\n            try {\n                await this.resolveImport(importCall, depth);\n            }\n            catch (e) {\n                if (this.options.onError) {\n                    this.options.onError?.((e as Error).message ?? e);\n                }\n                else {\n                    console.error(e);\n                }\n            }\n        }\n    }\n\n    private async resolveImport(importResource: ImportResourcePath, depth: RecursionDepth) {\n        const hash = this.hashImportResourcePath(importResource);\n        if (this.loadedFiles.includes(hash)) {\n            return;\n        }\n\n        this.loadedFiles.push(hash);\n        console.log(\"resolveImport\", importResource, depth);\n\n        // Ignore these package imports as they are well-known to be pointless.\n        if (importResource.kind == \"package\" && importResource.packageName == \"require\")\n            return null;\n\n        switch (importResource.kind) {\n            case 'package':\n                const packageRelativeImport = await this.resolveImportFromPackageRoot(importResource);\n                if (packageRelativeImport) {\n                    return await this.resolveImportInPackage(packageRelativeImport, depth.nextPackage().nextFile());\n                }\n                break;\n            case 'relative':\n                throw Error('Not implemented yet');\n            case 'relative-in-package':\n                return await this.resolveImportInPackage(importResource, depth.nextFile());\n            case 'bruteforce': {\n\n            }\n        }\n    }\n\n    private async resolveImportInPackage(importResource: ImportResourcePathRelativeInPackage, depth: RecursionDepth) {\n        console.log(\"resolveImportInPackage\", importResource, depth);\n\n        const contents = await this.loadSourceFileContents(importResource);\n\n        if (contents) {\n            const { source, at } = contents;\n            this.createModel(\n                source,\n                this.monaco.Uri.parse(this.options.fileRootPath + path.join(`node_modules/${importResource.packageName}`, at))\n            );\n\n            await this.resolveImportsInFile(\n                source,\n                {\n                    kind: 'relative-in-package',\n                    packageName: importResource.packageName,\n                    sourcePath: path.dirname(at),\n                    importPath: '',\n                },\n                depth\n            );\n        }\n    }\n\n    private async resolveImportFromPackageRoot(\n        importResource: ImportResourcePathPackage\n    ): Promise<ImportResourcePathRelativeInPackage | void> {\n        console.log(\"resolveImportFromPackageRoot\", importResource);\n\n        const failedProgressUpdate = {\n            type: 'LookedUpPackage',\n            package: importResource.packageName,\n            definitelyTyped: false,\n            success: false,\n        } as const;\n\n        if (this.options.onlySpecifiedPackages) {\n            if (!this.versions?.[importResource.packageName] && !this.versions?.['@types/' + importResource.packageName]) {\n                invokeUpdate(failedProgressUpdate, this.options);\n                return null;\n            }\n        }\n\n        const doesPkgJsonHasSubpath = importResource.importPath?.length ?? 0 > 0;\n        let pkgJsonSubpath = doesPkgJsonHasSubpath ? `/${importResource.importPath}` : '';\n        let pkgJson = await this.resolvePackageJson(\n            importResource.packageName,\n            this.versions?.[importResource.packageName],\n            doesPkgJsonHasSubpath ? importResource.importPath : undefined\n        );\n\n        if (!pkgJson && doesPkgJsonHasSubpath) {\n            pkgJson = await this.resolvePackageJson(importResource.packageName, this.versions?.[importResource.packageName]);\n            pkgJsonSubpath = '';\n        }\n\n        if (!pkgJson) return invokeUpdate(failedProgressUpdate, this.options);\n\n        const pkg = JSON.parse(pkgJson);\n\n        console.log(\"package meta\", pkg);\n\n        if (pkg.typings || pkg.types) {\n            const typings = pkg.typings || pkg.types;\n            this.createModel(\n                pkgJson,\n                this.monaco.Uri.parse(\n                    `${this.options.fileRootPath}node_modules/${importResource.packageName}${pkgJsonSubpath}/package.json`\n                )\n            );\n\n            invokeUpdate(\n                {\n                    type: 'LookedUpPackage',\n                    package: importResource.packageName,\n                    definitelyTyped: false,\n                    success: true,\n                },\n                this.options\n            );\n            this.setVersion(importResource.packageName, pkg.version);\n\n            return {\n                kind: 'relative-in-package',\n                packageName: importResource.packageName,\n                sourcePath: '',\n                importPath: path.join(importResource.importPath ?? '', typings.startsWith('./') ? typings.slice(2) : typings),\n            };\n        }\n        else {\n\n            const typingPackageName = `@types/${\n                importResource.packageName.startsWith('@')\n                    ? importResource.packageName.slice(1).replace(/\\//, '__')\n                    : importResource.packageName\n            }`;\n\n            const pkgJsonTypings = await this.resolvePackageJson(typingPackageName, this.versions?.[typingPackageName]);\n\n            if (!pkgJsonTypings)\n                return invokeUpdate(failedProgressUpdate, this.options);\n\n            const pkg = JSON.parse(pkgJsonTypings);\n\n            if (!pkg.typings && !pkg.types) {\n                const files: {\n                    fileCount: number,\n                    files: {\n                        [key: string]: {\n                            size: number,\n                            hex: string,\n                            type: \"File\",\n                            isBinary: \"true\" | \"false\",\n                            path: string,\n                            contentType: string\n                        }\n                    },\n                    integrity: string,\n                    shasum: string,\n                    totalSize: number\n                } = await fetch(\"https://www.npmjs.com/package/@dt-esa/dynatrace-api-client/v/2.2.6/index\", {\n                    method: \"get\"\n                }).then(e => e.json());\n\n                const typingFiles = Object.entries(files.files).map(([key, val]) => val);\n\n                invokeUpdate(\n                    {\n                        type: 'LookedUpPackage',\n                        package: typingPackageName,\n                        definitelyTyped: true,\n                        success: true,\n                    },\n                    this.options\n                );\n\n                return {\n                    kind: 'bruteforce',\n                    packageName: typingPackageName,\n                    typingFiles,\n                } as any;\n\n                return;\n                // return invokeUpdate(failedProgressUpdate, this.options);\n            }\n\n            const typings = pkg.typings || pkg.types;\n            this.createModel(\n                pkgJsonTypings,\n                this.monaco.Uri.parse(`${this.options.fileRootPath}node_modules/${typingPackageName}/package.json`)\n            );\n\n            invokeUpdate(\n                {\n                    type: 'LookedUpPackage',\n                    package: typingPackageName,\n                    definitelyTyped: true,\n                    success: true,\n                },\n                this.options\n            );\n            this.setVersion(typingPackageName, pkg.version);\n\n            return {\n                kind: 'relative-in-package',\n                packageName: typingPackageName,\n                sourcePath: '',\n                importPath: path.join(\n                    importResource.importPath ?? '',\n                    typings.startsWith('./') ? typings.slice(2) : typings\n                ),\n            };\n        }\n    }\n\n    private async loadSourceFileContents(\n        importResource: ImportResourcePathRelativeInPackage\n    ): Promise<{ source: string; at: string } | null> {\n        const progressUpdatePath = path.join(\n            importResource.packageName,\n            importResource.sourcePath,\n            importResource.importPath\n        );\n\n        const failedProgressUpdate = {\n            type: 'LookedUpTypeFile',\n            path: progressUpdatePath,\n            definitelyTyped: false,\n            success: false,\n        } as const;\n\n        const pkgName = importResource.packageName;\n        const version = this.getVersion(importResource.packageName);\n\n        let appends = ['.d.ts', '/index.d.ts', '.ts', '.tsx', '/index.ts', '/index.tsx'];\n\n        if (appends.map(append => importResource.importPath.endsWith(append)).reduce((a, b) => a || b, false)) {\n            const source = await this.resolveSourceFile(\n                pkgName,\n                version,\n                path.join(importResource.sourcePath, importResource.importPath)\n            );\n            if (source) {\n                return { source, at: path.join(importResource.sourcePath, importResource.importPath) };\n            }\n        }\n        else {\n            for (const append of appends) {\n                const fullPath = path.join(importResource.sourcePath, importResource.importPath) + append;\n                const source = await this.resolveSourceFile(pkgName, version, fullPath);\n                invokeUpdate(\n                    {\n                        type: 'AttemptedLookUpFile',\n                        path: path.join(pkgName, fullPath),\n                        success: !!source,\n                    },\n                    this.options\n                );\n                if (source) {\n                    invokeUpdate(\n                        {\n                            type: 'LookedUpTypeFile',\n                            path: path.join(pkgName, fullPath),\n                            success: true,\n                        },\n                        this.options\n                    );\n                    return { source, at: fullPath };\n                }\n            }\n        }\n\n        const pkgJson = await this.resolvePackageJson(\n            pkgName,\n            version,\n            path.join(importResource.sourcePath, importResource.importPath)\n        );\n\n        if (pkgJson) {\n            const { types } = JSON.parse(pkgJson);\n            if (types) {\n                const fullPath = path.join(importResource.sourcePath, importResource.importPath, types);\n                const source = await this.resolveSourceFile(pkgName, version, fullPath);\n                if (source) {\n                    invokeUpdate(\n                        {\n                            type: 'LookedUpTypeFile',\n                            path: path.join(pkgName, fullPath),\n                            success: true,\n                        },\n                        this.options\n                    );\n                    return { source, at: fullPath };\n                }\n            }\n        }\n\n        invokeUpdate(failedProgressUpdate, this.options);\n        return null;\n    }\n\n    private getVersion(packageName: string) {\n        return this.versions?.[packageName];\n    }\n\n    public setVersions(versions: { [packageName: string]: string }) {\n        this.versions = versions;\n        this.options.onUpdateVersions?.(versions);\n        // TODO reload packages whose version has changed\n    }\n\n    private setVersion(packageName: string, version: string) {\n        this.setVersions({\n            ...this.versions,\n            [packageName]: version,\n        });\n    }\n\n    private createModel(source: string, uri: monaco.Uri) {\n        uri = uri.with({ path: uri.path.replace('@types/', '') });\n        if (!this.monaco.editor.getModel(uri)) {\n            this.monaco.editor.createModel(source, 'typescript', uri);\n            this.newImportsResolved = true;\n        }\n    }\n\n    private hashImportResourcePath(p: ImportResourcePath) {\n        return importResourcePathToString(p);\n    }\n\n    private async resolvePackageJson(\n        packageName: string,\n        version?: string,\n        subPath?: string\n    ): Promise<string | undefined> {\n\n        const uri = path.join(packageName + (version ? `@${version}` : ''), subPath ?? '', 'package.json');\n        let isAvailable = false;\n        let content: string | undefined = undefined;\n\n        if (this.cache.isFileAvailable) {\n            isAvailable = await this.cache.isFileAvailable(uri);\n        }\n        else {\n            content = await this.cache.getFile(uri);\n            isAvailable = content !== undefined;\n        }\n\n        if (isAvailable) {\n            return content ?? (await this.cache.getFile(uri));\n        }\n        else {\n            console.log(\"recursing resolvePackageJson\", packageName, version, subPath)\n            content = await UnpkgSourceResolver.resolvePackageJson(packageName, version, subPath);\n            if (content) {\n                this.cache.storeFile(uri, content);\n            }\n            return content;\n        }\n    }\n\n    private async resolveSourceFile(\n        packageName: string,\n        version: string | undefined,\n        filePath: string\n    ): Promise<string | undefined> {\n\n        const uri = path.join(packageName + (version ? `@${version}` : ''), filePath);\n        let isAvailable = false;\n        let content: string | undefined = undefined;\n\n        if (this.cache.isFileAvailable) {\n            isAvailable = await this.cache.isFileAvailable(uri);\n        }\n        else {\n            content = await this.cache.getFile(uri);\n            isAvailable = content !== undefined;\n        }\n\n        if (isAvailable) {\n            invokeUpdate(\n                {\n                    type: 'LoadedFromCache',\n                    importPath: uri,\n                },\n                this.options\n            );\n            return content ?? (await this.cache.getFile(uri));\n        }\n        else {\n            content = await UnpkgSourceResolver.resolveSourceFile(packageName, version, filePath);\n            if (content) {\n                invokeUpdate(\n                    {\n                        type: 'StoredToCache',\n                        importPath: uri,\n                    },\n                    this.options\n                );\n                this.cache.storeFile(uri, content);\n            }\n            return content;\n        }\n    }\n}\n"]}

package/esm2020/components/vscode/ts-type-resolver/main.mjs

@@ -0,0 +1,112 @@
+import { ImportResolver } from './import-resolver';
+import * as path from 'path-browserify';
+import { invokeUpdate } from './update-emitter';
+import { RecursionDepth } from './recursion-depth';
+import { DummySourceCache } from './dummy-source-cache';
+// https://github.com/lukasbach/monaco-editor-auto-typings
+export class MonacoAutoTypeImporter {
+    constructor(editor, options) {
+        this.editor = editor;
+        this.options = options;
+        this.disposables = [];
+        this.importResolver = new ImportResolver(options);
+        const changeModelDisposable = editor.onDidChangeModelContent(e => {
+            this.debouncedResolveContents();
+        });
+        this.disposables.push(changeModelDisposable);
+        this.resolveContents();
+        if (!options.dontAdaptEditorOptions) {
+            options.monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+                ...options.monaco.languages.typescript.typescriptDefaults.getCompilerOptions(),
+                moduleResolution: options.monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+                allowSyntheticDefaultImports: true,
+                rootDir: options.fileRootPath,
+            });
+        }
+    }
+    static async create(editor, options) {
+        if (options?.shareCache && options.sourceCache && !MonacoAutoTypeImporter.sharedCache) {
+            MonacoAutoTypeImporter.sharedCache = options.sourceCache;
+        }
+        const monacoInstance = options?.monaco ?? window['monaco'];
+        if (!monacoInstance) {
+            throw new Error('monacoInstance not found, you can specify the monaco instance via options.monaco');
+        }
+        return new MonacoAutoTypeImporter(editor, {
+            fileRootPath: 'inmemory://model/',
+            onlySpecifiedPackages: false,
+            preloadPackages: false,
+            shareCache: false,
+            dontAdaptEditorOptions: false,
+            dontRefreshModelValueAfterResolvement: false,
+            sourceCache: MonacoAutoTypeImporter.sharedCache ?? new DummySourceCache(),
+            debounceDuration: 4000,
+            fileRecursionDepth: 10,
+            packageRecursionDepth: 3,
+            ...options,
+            monaco: monacoInstance,
+        });
+    }
+    dispose() {
+        this.disposables.forEach(d => d.dispose());
+    }
+    setVersions(versions) {
+        this.importResolver.setVersions(versions);
+        this.options.versions = versions;
+    }
+    async clearCache() {
+        await this.options.sourceCache.clear();
+    }
+    debouncedResolveContents() {
+        if (this.isResolving) {
+            return;
+        }
+        invokeUpdate({ type: 'CodeChanged' }, this.options);
+        if (this.options.debounceDuration <= 0) {
+            this.resolveContents();
+        }
+        else {
+            if (this.debounceTimer !== undefined) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(async () => {
+                await this.resolveContents();
+                this.debounceTimer = undefined;
+            }, this.options.debounceDuration);
+        }
+    }
+    async resolveContents() {
+        this.isResolving = true;
+        invokeUpdate({ type: 'ResolveNewImports' }, this.options);
+        const model = this.editor.getModel();
+        // This can happen when the editor is disposed before all typings
+        // are installed.
+        if (!model) {
+            throw Error('No model');
+        }
+        const content = model.getLinesContent();
+        try {
+            await this.importResolver.resolveImportsInFile(content.join('\n'), path.dirname(model.uri.toString()), new RecursionDepth(this.options));
+        }
+        catch (e) {
+            if (this.options.onError) {
+                this.options.onError(e.message ?? e);
+            }
+            else {
+                throw e;
+            }
+        }
+        if (this.importResolver.wereNewImportsResolved()) {
+            if (!this.options.dontRefreshModelValueAfterResolvement) {
+                const currentPosition = this.editor.getPosition();
+                model.setValue(model.getValue());
+                if (currentPosition) {
+                    this.editor.setPosition(currentPosition);
+                }
+            }
+            this.importResolver.resetNewImportsResolved();
+        }
+        this.isResolving = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../../../../packages/common/src/components/vscode/ts-type-resolver/main.ts"],"names":[],"mappings":"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","sourcesContent":["import { ImportResolver } from './import-resolver';\nimport * as path from 'path-browserify';\nimport type * as monaco from 'monaco-editor';\nimport { invokeUpdate } from './update-emitter';\nimport { RecursionDepth } from './recursion-depth';\nimport { Options, SourceCache } from './types';\nimport { DummySourceCache } from './dummy-source-cache';\n\ntype Editor = monaco.editor.ICodeEditor | monaco.editor.IStandaloneCodeEditor;\n\n// https://github.com/lukasbach/monaco-editor-auto-typings\nexport class MonacoAutoTypeImporter implements monaco.IDisposable {\n    private static sharedCache?: SourceCache;\n    private importResolver: ImportResolver;\n    private debounceTimer?: number;\n    private isResolving?: boolean;\n    private disposables: monaco.IDisposable[] = [];\n\n    public constructor(private editor: Editor, private options: Options) {\n        this.importResolver = new ImportResolver(options);\n\n        const changeModelDisposable = editor.onDidChangeModelContent(e => {\n            this.debouncedResolveContents();\n        });\n        this.disposables.push(changeModelDisposable);\n        this.resolveContents();\n\n        if (!options.dontAdaptEditorOptions) {\n            options.monaco.languages.typescript.typescriptDefaults.setCompilerOptions({\n                ...options.monaco.languages.typescript.typescriptDefaults.getCompilerOptions(),\n                moduleResolution: options.monaco.languages.typescript.ModuleResolutionKind.NodeJs,\n                allowSyntheticDefaultImports: true,\n                rootDir: options.fileRootPath,\n            });\n        }\n    }\n\n    public static async create(editor: Editor, options?: Partial<Options>): Promise<MonacoAutoTypeImporter> {\n        if (options?.shareCache && options.sourceCache && !MonacoAutoTypeImporter.sharedCache) {\n            MonacoAutoTypeImporter.sharedCache = options.sourceCache;\n        }\n\n        const monacoInstance = options?.monaco ?? window['monaco'];\n\n        if (!monacoInstance) {\n            throw new Error('monacoInstance not found, you can specify the monaco instance via options.monaco');\n        }\n\n        return new MonacoAutoTypeImporter(editor, {\n            fileRootPath: 'inmemory://model/',\n            onlySpecifiedPackages: false,\n            preloadPackages: false,\n            shareCache: false,\n            dontAdaptEditorOptions: false,\n            dontRefreshModelValueAfterResolvement: false,\n            sourceCache: MonacoAutoTypeImporter.sharedCache ?? new DummySourceCache(),\n            debounceDuration: 4000,\n            fileRecursionDepth: 10,\n            packageRecursionDepth: 3,\n            ...options,\n            monaco: monacoInstance,\n        });\n    }\n\n    public dispose() {\n        this.disposables.forEach(d => d.dispose())\n    }\n\n    public setVersions(versions: { [packageName: string]: string }) {\n        this.importResolver.setVersions(versions);\n        this.options.versions = versions;\n    }\n\n    public async clearCache() {\n        await this.options.sourceCache.clear();\n    }\n\n    private debouncedResolveContents() {\n        if (this.isResolving) {\n            return;\n        }\n\n        invokeUpdate({ type: 'CodeChanged' }, this.options);\n\n        if (this.options.debounceDuration <= 0) {\n            this.resolveContents();\n        }\n        else {\n            if (this.debounceTimer !== undefined) {\n                clearTimeout(this.debounceTimer);\n            }\n            this.debounceTimer = setTimeout(async () => {\n                await this.resolveContents();\n                this.debounceTimer = undefined;\n            }, this.options.debounceDuration) as any;\n        }\n    }\n\n    private async resolveContents() {\n        this.isResolving = true;\n        invokeUpdate({ type: 'ResolveNewImports' }, this.options);\n\n        const model = this.editor.getModel();\n        // This can happen when the editor is disposed before all typings\n        // are installed.\n        if (!model) {\n            throw Error('No model');\n        }\n\n        const content = model.getLinesContent();\n\n        try {\n            await this.importResolver.resolveImportsInFile(\n                content.join('\\n'),\n                path.dirname(model.uri.toString()),\n                new RecursionDepth(this.options)\n            );\n        }\n        catch (e) {\n            if (this.options.onError) {\n                this.options.onError((e as Error).message ?? e);\n            }\n            else {\n                throw e;\n            }\n        }\n\n        if (this.importResolver.wereNewImportsResolved()) {\n            if (!this.options.dontRefreshModelValueAfterResolvement) {\n                const currentPosition = this.editor.getPosition();\n                model.setValue(model.getValue());\n                if (currentPosition) {\n                    this.editor.setPosition(currentPosition);\n                }\n            }\n            this.importResolver.resetNewImportsResolved();\n        }\n\n        this.isResolving = false;\n    }\n}\n"]}

package/esm2020/components/vscode/ts-type-resolver/recursion-depth.mjs

@@ -0,0 +1,21 @@
+export class RecursionDepth {
+    constructor(options, fileRecursionDepth = 0, packageRecursionDepth = 0) {
+        this.options = options;
+        this.fileRecursionDepth = fileRecursionDepth;
+        this.packageRecursionDepth = packageRecursionDepth;
+    }
+    nextPackage() {
+        return new RecursionDepth(this.options, this.fileRecursionDepth, this.packageRecursionDepth + 1);
+    }
+    nextFile() {
+        return new RecursionDepth(this.options, this.fileRecursionDepth + 1, this.packageRecursionDepth);
+    }
+    same() {
+        return new RecursionDepth(this.options, this.fileRecursionDepth, this.packageRecursionDepth);
+    }
+    shouldStop() {
+        return ((this.options.fileRecursionDepth > 0 && this.fileRecursionDepth >= this.options.fileRecursionDepth) ||
+            (this.options.packageRecursionDepth > 0 && this.packageRecursionDepth >= this.options.packageRecursionDepth));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/vscode/ts-type-resolver/types.mjs

@@ -0,0 +1,14 @@
+import * as path from 'path-browserify';
+export const importResourcePathToString = (p) => {
+    switch (p.kind) {
+        case 'package':
+            return path.join(p.packageName, p.importPath ?? '', 'package.json');
+        case 'relative':
+            return path.join(p.sourcePath, p.importPath);
+        case 'relative-in-package':
+            return path.join(p.packageName, p.sourcePath, p.importPath);
+        case 'bruteforce':
+            throw new Error("Not Implemented");
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../packages/common/src/components/vscode/ts-type-resolver/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AAkNxC,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAqB,EAAE,EAAE;IAChE,QAAQ,CAAC,CAAC,IAAI,EAAE;QACZ,KAAK,SAAS;YACV,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,UAAU,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC;QACxE,KAAK,UAAU;YACX,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;QACjD,KAAK,qBAAqB;YACtB,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;QAChE,KAAK,YAAY;YACb,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;KAC1C;AACL,CAAC,CAAC","sourcesContent":["import type * as monaco from 'monaco-editor';\nimport * as path from 'path-browserify';\n\nexport interface SourceCache {\n    isFileAvailable?: (uri: string) => Promise<boolean>;\n    storeFile: (uri: string, content: string) => Promise<void>;\n    getFile: (uri: string) => Promise<string | undefined>;\n    clear: () => Promise<void>;\n}\n\nexport type ProgressUpdate =\n    | {\n        type: 'CodeChanged';\n    }\n    | {\n        type: 'ResolveNewImports';\n    }\n    | {\n        type: 'LookedUpTypeFile';\n        path: string;\n        success: boolean;\n    }\n    | {\n        type: 'AttemptedLookUpFile';\n        path: string;\n        success: boolean;\n    }\n    | {\n        type: 'LookedUpPackage';\n        package: string;\n        definitelyTyped: boolean;\n        success: boolean;\n    }\n    | {\n        type: 'LoadedFromCache';\n        importPath: string;\n    }\n    | {\n        type: 'StoredToCache';\n        importPath: string;\n    };\n\n\n\nexport interface Options {\n    /**\n     * Share source cache between multiple editor instances by storing\n     * the cache in a static property.\n     *\n     * Defaults to false.\n     */\n    shareCache: boolean;\n\n    /**\n     * Only use packages specified in the `versions` property.\n     *\n     * Defaults to false.\n     */\n    onlySpecifiedPackages: boolean;\n\n    /**\n     * Load typings from prespecified versions when initializing. Versions\n     * need to be specified in the ``versions`` option.\n     *\n     * Defaults to false.\n     */\n    preloadPackages: boolean;\n\n    /**\n     * Updates compiler options to defaults suitable for auto-loaded\n     * declarations, specifically by setting ``moduleResolution`` to\n     * ``NodeJs`` and ``allowSyntheticDefaultImports`` to true.\n     * Other options are not changed. Set this property to true to\n     * disable this behaviour.\n     *\n     * Defaults to false.\n     */\n    dontAdaptEditorOptions: boolean;\n\n    /**\n     * After typings were resolved and injected into monaco, auto-typings\n     * updates the value of the current model to trigger a refresh in\n     * monaco's typing logic, so that it uses the injected typings.\n     */\n    dontRefreshModelValueAfterResolvement: boolean;\n\n    /**\n     * Prespecified package versions. If a package is loaded whose\n     * name is specified in this object, it will load with the exact\n     * version specified in the object.\n     *\n     * Example:\n     *\n     * ```json\n     * {\n     *   \"@types/react\": \"17.0.0\",\n     *   \"csstype\": \"3.0.5\"\n     * }\n     * ```\n     *\n     * Setting the option ``onlySpecifiedPackages`` to true makes this\n     * property act as a whitelist for packages.\n     *\n     * Setting the option ``preloadPackages`` makes the packages specified\n     * in this property load directly after initializing the auto-loader.\n     */\n    versions?: { [packageName: string]: string; };\n\n    /**\n     * If a new package was loaded, its name and version is added to the\n     * version object, and this method is called with the updated object.\n     * @param versions updated versions object.\n     */\n    onUpdateVersions?: (versions: { [packageName: string]: string; }) => void;\n\n    /**\n     * Supply a cache where declaration files and package.json files are\n     * cached to. Supply an instance of {@link LocalStorageCache} to cache\n     * files to localStorage.\n     */\n    sourceCache: SourceCache;\n\n    /**\n     * The root directory where your edited files are. Must end with\n     * a slash. The default is suitable unless you change the default\n     * URI of files loaded in the editor.\n     *\n     * Defaults to \"inmemory://model/\"\n     */\n    fileRootPath: string;\n\n    /**\n     * Debounces code reanalyzing after user has changed the editor contents\n     * by the specified amount. Set to zero to disable. Value provided in\n     * milliseconds.\n     *\n     * Defaults to 4000, i.e. 4 seconds.\n     */\n    debounceDuration: number;\n\n    /**\n     * Maximum recursion depth for recursing packages. Determines how many\n     * nested package declarations are loaded. For example, if ``packageRecursionDepth``\n     * has the value 2, the code in the monaco editor references packages ``A1``, ``A2``\n     * and ``A3``, package ``A1`` references package ``B1`` and ``B1`` references ``C1``,\n     * then packages ``A1``, ``A2``, ``A3`` and ``B1`` are loaded. Set to zero to\n     * disable.\n     *\n     * Defaults to 3.\n     */\n    packageRecursionDepth: number;\n\n    /**\n     * Maximum recursion depth for recursing files. Determines how many\n     * nested file declarations are loaded. The same as ``packageRecursionDepth``,\n     * but for individual files. Set to zero to disable.\n     *\n     * Defaults to 10.\n     */\n    fileRecursionDepth: number;\n\n    /**\n     * Called after progress updates like loaded declarations or events.\n     * @param update detailed event object containing update infos.\n     * @param textual a textual representation of the update for debugging.\n     */\n    onUpdate?: (update: ProgressUpdate, textual: string) => void;\n\n    /**\n     * Called if errors occur.\n     * @param error a textual representation of the error.\n     */\n    onError?: (error: string) => void;\n    /**\n     * instance of monaco editor\n     */\n    monaco: typeof monaco;\n}\n\n\nexport interface ImportResourcePathPackage {\n    kind: 'package';\n    packageName: string;\n    importPath?: string;\n}\n\nexport interface ImportResourcePathRelative {\n    kind: 'relative';\n    importPath: string;\n    sourcePath: string;\n}\n\nexport interface ImportResourcePathRelativeInPackage {\n    kind: 'relative-in-package';\n    packageName: string;\n    importPath: string;\n    sourcePath: string;\n}\n\nexport interface ImportResourceBruteForce {\n    kind: 'bruteforce';\n    packageName: string;\n    typingFiles: any[];\n}\n\nexport type ImportResourcePath =\n    | ImportResourcePathPackage\n    | ImportResourcePathRelative\n    | ImportResourcePathRelativeInPackage\n    | ImportResourceBruteForce;\n\nexport const importResourcePathToString = (p: ImportResourcePath) => {\n    switch (p.kind) {\n        case 'package':\n            return path.join(p.packageName, p.importPath ?? '', 'package.json');\n        case 'relative':\n            return path.join(p.sourcePath, p.importPath);\n        case 'relative-in-package':\n            return path.join(p.packageName, p.sourcePath, p.importPath);\n        case 'bruteforce':\n            throw new Error(\"Not Implemented\");\n    }\n};\n"]}

package/esm2020/components/vscode/ts-type-resolver/unpkg-source-resolver.mjs

@@ -0,0 +1,21 @@
+export class UnpkgSourceResolver {
+    static async resolvePackageJson(packageName, version, subPath) {
+        return await this.resolveFile(`https://unpkg.com/${packageName}${version ? `@${version}` : ''}${subPath ? `/${subPath}` : ''}/package.json`);
+    }
+    static async resolveSourceFile(packageName, version, path) {
+        return await this.resolveFile(`https://unpkg.com/${packageName}${version ? `@${version}` : ''}/${path}`);
+    }
+    static async resolveFile(url) {
+        const res = await fetch(url, { method: 'GET' });
+        if (res.ok) {
+            return await res.text();
+        }
+        else if (res.status === 404) {
+            return '';
+        }
+        else {
+            throw Error(`Error other than 404 while fetching from Unpkg at ${url}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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