@dotglitch/ngx-common 1.0.21 → 1.0.23

package/esm2020/components/vscode/ts-type-resolver/dependency-parser.mjs

@@ -0,0 +1,91 @@
+import * as path from 'path-browserify';
+export class DependencyParser {
+    constructor() {
+        this.REGEX_NODE_MODULE = /^node:([\w\W\/]+)$/;
+    }
+    // https://github.com/lukasbach/monaco-editor-auto-typings/commit/fc046e7d9a2abbb5121ad8ab25195d8c1c277416
+    parseDependencies(source, parent) {
+        const importRegex = /import *.+ *from *['"](?<importPath>.+?)['"]/g;
+        const dynamicImportRegex = /await import ?\(['"](?<importPath>.+?)['"]\)/g;
+        const cjsRequireRegex = /require *\(['"](?<importPath>.+?)['"]\)/g;
+        const matches = [
+            ...source.matchAll(importRegex),
+            ...source.matchAll(dynamicImportRegex),
+            ...source.matchAll(cjsRequireRegex)
+        ];
+        const importPaths = matches.map(match => match.groups?.['importPath']);
+        const result = importPaths.map(imp => this.resolvePath(imp, parent));
+        return result;
+    }
+    resolvePath(importPath, parent) {
+        const nodeImport = importPath.match(this.REGEX_NODE_MODULE);
+        if (nodeImport) {
+            return {
+                kind: 'relative-in-package',
+                packageName: '@types/node',
+                importPath: `${nodeImport[1]}.d.ts`,
+                sourcePath: '',
+            };
+        }
+        if (typeof parent === 'string') {
+            if (importPath.startsWith('.')) {
+                return {
+                    kind: 'relative',
+                    importPath,
+                    sourcePath: parent,
+                };
+            }
+            else if (importPath.startsWith('@')) {
+                const segments = importPath.split('/');
+                return {
+                    kind: 'package',
+                    packageName: `${segments[0]}/${segments[1]}`,
+                    importPath: segments.slice(2).join('/'),
+                };
+            }
+            else {
+                const segments = importPath.split('/');
+                return {
+                    kind: 'package',
+                    packageName: segments[0],
+                    importPath: segments.slice(1).join('/'),
+                };
+            }
+        }
+        else {
+            switch (parent.kind) {
+                case 'package':
+                    throw Error('TODO?');
+                case 'relative':
+                    throw Error('TODO2?');
+                case 'relative-in-package':
+                    if (importPath.startsWith('.')) {
+                        return {
+                            kind: 'relative-in-package',
+                            packageName: parent.packageName,
+                            sourcePath: path.join(parent.sourcePath, parent.importPath),
+                            importPath: importPath,
+                        };
+                    }
+                    else if (importPath.startsWith('@')) {
+                        const segments = importPath.split('/');
+                        return {
+                            kind: 'package',
+                            packageName: `${segments[0]}/${segments[1]}`,
+                            importPath: segments.slice(2).join('/'),
+                        };
+                    }
+                    else {
+                        const segments = importPath.split('/');
+                        return {
+                            kind: 'package',
+                            packageName: segments[0],
+                            importPath: segments.slice(1).join('/'),
+                        };
+                    }
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-parser.js","sourceRoot":"","sources":["../../../../../../packages/common/src/components/vscode/ts-type-resolver/dependency-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AAGxC,MAAM,OAAO,gBAAgB;IAA7B;QACY,sBAAiB,GAAG,oBAAoB,CAAC;IA0FrD,CAAC;IAxFG,0GAA0G;IACnG,iBAAiB,CAAC,MAAc,EAAE,MAAmC;QACxE,MAAM,WAAW,GAAG,+CAA+C,CAAC;QACpE,MAAM,kBAAkB,GAAG,+CAA+C,CAAC;QAC3E,MAAM,eAAe,GAAG,0CAA0C,CAAC;QAEnE,MAAM,OAAO,GAAG;YACZ,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC/B,GAAG,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC;YACtC,GAAG,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC;SACtC,CAAC;QACF,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;QACvE,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;QAErE,OAAO,MAAM,CAAA;IACjB,CAAC;IAEO,WAAW,CAAC,UAAkB,EAAE,MAAmC;QACvE,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC5D,IAAI,UAAU,EAAE;YACZ,OAAO;gBACH,IAAI,EAAE,qBAAqB;gBAC3B,WAAW,EAAE,aAAa;gBAC1B,UAAU,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,OAAO;gBACnC,UAAU,EAAE,EAAE;aACjB,CAAC;SACL;QAED,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;YAC5B,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBAC5B,OAAO;oBACH,IAAI,EAAE,UAAU;oBAChB,UAAU;oBACV,UAAU,EAAE,MAAM;iBACrB,CAAC;aACL;iBACI,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACjC,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACvC,OAAO;oBACH,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE;oBAC5C,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;iBAC1C,CAAC;aACL;iBACI;gBACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACvC,OAAO;oBACH,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;oBACxB,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;iBAC1C,CAAC;aACL;SACJ;aACI;YACD,QAAQ,MAAM,CAAC,IAAI,EAAE;gBACjB,KAAK,SAAS;oBACV,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;gBACzB,KAAK,UAAU;oBACX,MAAM,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAC1B,KAAK,qBAAqB;oBACtB,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;wBAC5B,OAAO;4BACH,IAAI,EAAE,qBAAqB;4BAC3B,WAAW,EAAE,MAAM,CAAC,WAAW;4BAC/B,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;4BAC3D,UAAU,EAAE,UAAU;yBACzB,CAAC;qBACL;yBACI,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;wBACjC,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBACvC,OAAO;4BACH,IAAI,EAAE,SAAS;4BACf,WAAW,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE;4BAC5C,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;yBAC1C,CAAC;qBACL;yBACI;wBACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBACvC,OAAO;4BACH,IAAI,EAAE,SAAS;4BACf,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;4BACxB,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;yBAC1C,CAAC;qBACL;aACR;SACJ;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ","sourcesContent":["import * as path from 'path-browserify';\nimport { ImportResourcePath } from './types';\n\nexport class DependencyParser {\n    private REGEX_NODE_MODULE = /^node:([\\w\\W\\/]+)$/;\n\n    // https://github.com/lukasbach/monaco-editor-auto-typings/commit/fc046e7d9a2abbb5121ad8ab25195d8c1c277416\n    public parseDependencies(source: string, parent: ImportResourcePath | string): ImportResourcePath[] {\n        const importRegex = /import *.+ *from *['\"](?<importPath>.+?)['\"]/g;\n        const dynamicImportRegex = /await import ?\\(['\"](?<importPath>.+?)['\"]\\)/g;\n        const cjsRequireRegex = /require *\\(['\"](?<importPath>.+?)['\"]\\)/g;\n\n        const matches = [\n            ...source.matchAll(importRegex),\n            ...source.matchAll(dynamicImportRegex),\n            ...source.matchAll(cjsRequireRegex)\n        ];\n        const importPaths = matches.map(match => match.groups?.['importPath']);\n        const result = importPaths.map(imp => this.resolvePath(imp, parent));\n\n        return result\n    }\n\n    private resolvePath(importPath: string, parent: ImportResourcePath | string): ImportResourcePath {\n        const nodeImport = importPath.match(this.REGEX_NODE_MODULE);\n        if (nodeImport) {\n            return {\n                kind: 'relative-in-package',\n                packageName: '@types/node',\n                importPath: `${nodeImport[1]}.d.ts`,\n                sourcePath: '',\n            };\n        }\n\n        if (typeof parent === 'string') {\n            if (importPath.startsWith('.')) {\n                return {\n                    kind: 'relative',\n                    importPath,\n                    sourcePath: parent,\n                };\n            }\n            else if (importPath.startsWith('@')) {\n                const segments = importPath.split('/');\n                return {\n                    kind: 'package',\n                    packageName: `${segments[0]}/${segments[1]}`,\n                    importPath: segments.slice(2).join('/'),\n                };\n            }\n            else {\n                const segments = importPath.split('/');\n                return {\n                    kind: 'package',\n                    packageName: segments[0],\n                    importPath: segments.slice(1).join('/'),\n                };\n            }\n        }\n        else {\n            switch (parent.kind) {\n                case 'package':\n                    throw Error('TODO?');\n                case 'relative':\n                    throw Error('TODO2?');\n                case 'relative-in-package':\n                    if (importPath.startsWith('.')) {\n                        return {\n                            kind: 'relative-in-package',\n                            packageName: parent.packageName,\n                            sourcePath: path.join(parent.sourcePath, parent.importPath),\n                            importPath: importPath,\n                        };\n                    }\n                    else if (importPath.startsWith('@')) {\n                        const segments = importPath.split('/');\n                        return {\n                            kind: 'package',\n                            packageName: `${segments[0]}/${segments[1]}`,\n                            importPath: segments.slice(2).join('/'),\n                        };\n                    }\n                    else {\n                        const segments = importPath.split('/');\n                        return {\n                            kind: 'package',\n                            packageName: segments[0],\n                            importPath: segments.slice(1).join('/'),\n                        };\n                    }\n            }\n        }\n        return null;\n    }\n}\n"]}

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

@@ -0,0 +1,15 @@
+export class DummySourceCache {
+    getFile(uri) {
+        return undefined;
+    }
+    async isFileAvailable(uri) {
+        return false;
+    }
+    storeFile(uri, content) {
+        return undefined;
+    }
+    clear() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHVtbXktc291cmNlLWNhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy9jb21wb25lbnRzL3ZzY29kZS90cy10eXBlLXJlc29sdmVyL2R1bW15LXNvdXJjZS1jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sZ0JBQWdCO0lBQ2xCLE9BQU8sQ0FBQyxHQUFXO1FBQ3RCLE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7SUFFTSxLQUFLLENBQUMsZUFBZSxDQUFDLEdBQVc7UUFDcEMsT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztJQUVNLFNBQVMsQ0FBQyxHQUFXLEVBQUUsT0FBZTtRQUN6QyxPQUFPLFNBQVMsQ0FBQztJQUNyQixDQUFDO0lBRU0sS0FBSztRQUNSLE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNvdXJjZUNhY2hlIH0gZnJvbSAnLi90eXBlcyc7XG5cbmV4cG9ydCBjbGFzcyBEdW1teVNvdXJjZUNhY2hlIGltcGxlbWVudHMgU291cmNlQ2FjaGUge1xuICAgIHB1YmxpYyBnZXRGaWxlKHVyaTogc3RyaW5nKTogUHJvbWlzZTxzdHJpbmcgfCB1bmRlZmluZWQ+IHtcbiAgICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICB9XG5cbiAgICBwdWJsaWMgYXN5bmMgaXNGaWxlQXZhaWxhYmxlKHVyaTogc3RyaW5nKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG5cbiAgICBwdWJsaWMgc3RvcmVGaWxlKHVyaTogc3RyaW5nLCBjb250ZW50OiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICB9XG5cbiAgICBwdWJsaWMgY2xlYXIoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxufVxuIl19

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":"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","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"]}