@dotglitch/ngx-common 2.0.0 → 3.0.0-beta.2

package/esm2022/monaco-editor/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/monaco-editor/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/esm2022/monaco-editor/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/monaco-editor/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/esm2022/monaco-editor/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/esm2022/monaco-editor/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/monaco-editor/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,CAAC;QACb,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;IAC3C,CAAC;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/esm2022/monaco-editor/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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