@nx-dart/nx-dart/src/generators/workspace/analysis-options.js

A Nx plugin, that adds support for developing Dart and Flutter packages in a Nx workspace

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.updateLintRulesInAnalysisOptions = exports.excludeNodeModulesFromAnalysisOptions = exports.LintRules = exports.ensureWorkspaceAnalysisOptions = void 0;
const tslib_1 = require("tslib");
const node_fetch_1 = require("node-fetch");
const YAML = require("yaml");
const dart_source_1 = require("../../utils/dart-source");
const package_1 = require("../../utils/package");
const generator_1 = require("../utils/generator");
const nx_workspace_1 = require("../utils/nx-workspace");
const workspaceAnalysisOptions = `
analyzer:
  language:
    strict-casts: true
    strict-inference: true
    strict-raw-types: true
`;
function ensureWorkspaceAnalysisOptions(tree) {
    if (!tree.exists('analysis_options.yaml')) {
        tree.write('analysis_options.yaml', workspaceAnalysisOptions);
    }
    (0, nx_workspace_1.updateNxJson)(tree, (nxJson) => {
        var _a;
        // Make the analysis_options.yaml file at the workspace root an implicit dependencies.
        const implicitDependencies = (nxJson.implicitDependencies =
            (_a = nxJson.implicitDependencies) !== null && _a !== void 0 ? _a : {});
        if (!('analysis_options.yaml' in implicitDependencies)) {
            implicitDependencies['analysis_options.yaml'] = '*';
        }
        return nxJson;
    });
}
exports.ensureWorkspaceAnalysisOptions = ensureWorkspaceAnalysisOptions;
var LintRules;
(function (LintRules) {
    LintRules["core"] = "core";
    LintRules["recommended"] = "recommended";
    LintRules["flutter"] = "flutter";
    LintRules["all"] = "all";
})(LintRules = exports.LintRules || (exports.LintRules = {}));
function excludeNodeModulesFromAnalysisOptions(tree) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        const analysisOptions = tree.read('analysis_options.yaml', 'utf-8');
        const doc = YAML.parseDocument(analysisOptions);
        let contents;
        if (doc.contents instanceof YAML.YAMLMap) {
            contents = doc.contents;
        }
        else {
            contents = new YAML.YAMLMap();
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            doc.contents = contents;
        }
        let analyzer = contents.get('analyzer');
        if (!(analyzer instanceof YAML.YAMLMap)) {
            analyzer = new YAML.YAMLMap();
            contents.set(doc.createNode('analyzer'), analyzer);
        }
        let exclude = analyzer.get('exclude');
        if (!(exclude instanceof YAML.YAMLSeq)) {
            exclude = new YAML.YAMLSeq();
            analyzer.items.splice(0, 0, doc.createPair('exclude', exclude));
        }
        if (!exclude.toJSON().includes('node_modules/**')) {
            exclude.add(doc.createNode('node_modules/**'));
        }
        tree.write('analysis_options.yaml', doc.toString());
    });
}
exports.excludeNodeModulesFromAnalysisOptions = excludeNodeModulesFromAnalysisOptions;
function updateLintRulesInAnalysisOptions(tree, lints) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        const analysisOptions = tree.read('analysis_options.yaml', 'utf-8');
        const doc = YAML.parseDocument(analysisOptions);
        let contents;
        if (doc.contents instanceof YAML.YAMLMap) {
            contents = doc.contents;
        }
        else {
            contents = new YAML.YAMLMap();
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            doc.contents = contents;
        }
        // Include analysis options from package or inline lint rules.
        const currentInclude = contents.get('include');
        let include;
        switch (lints) {
            case LintRules.core:
                include = 'package:lints/core.yaml';
                break;
            case LintRules.recommended:
                include = 'package:lints/recommended.yaml';
                break;
            case LintRules.flutter:
                include = 'package:flutter_lints/flutter.yaml';
                break;
            case LintRules.all:
                include = './all_lint_rules.yaml';
                tree.write(include, yield downloadAllLintRules());
                break;
        }
        if (contents.get('include') !== include) {
            contents.delete('include');
            if (include) {
                contents.items.splice(0, 0, doc.createPair('include', include));
            }
        }
        tree.write('analysis_options.yaml', doc.toString());
        // Change included package in pubspec.yaml if necessary.
        const tasks = [];
        const includedPackage = include ? (0, dart_source_1.packageNameFromUri)(include) : undefined;
        const currentIncludedPackage = currentInclude
            ? (0, dart_source_1.packageNameFromUri)(currentInclude)
            : undefined;
        if (currentIncludedPackage !== includedPackage) {
            if (currentIncludedPackage) {
                tasks.push(() => (0, package_1.removeDependencyFromPackage)('.', currentIncludedPackage));
            }
            if (includedPackage) {
                tasks.push(() => (0, package_1.addHostedDependencyToPackage)('.', includedPackage, { dev: true }));
            }
        }
        return (0, generator_1.runAllTasks)(tasks);
    });
}
exports.updateLintRulesInAnalysisOptions = updateLintRulesInAnalysisOptions;
function downloadAllLintRules() {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        const analysisOptionsUrl = 'https://raw.githubusercontent.com/dart-lang/linter/master/example/all.yaml';
        const response = yield (0, node_fetch_1.default)(analysisOptionsUrl);
        if (!response.ok) {
            throw new Error(`Could not download all lint rules from ${analysisOptionsUrl}: ${response.statusText}`);
        }
        return yield response.text();
    });
}
//# sourceMappingURL=analysis-options.js.map