@kcinternals/nx-plugin/src/utils/generators.js

nx plugins for kcws internal usage

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    createAndUpdateGeneratorsJson: function() {
        return createAndUpdateGeneratorsJson;
    },
    getGeneratorInformation: function() {
        return getGeneratorInformation;
    },
    getGeneratorJson: function() {
        return getGeneratorJson;
    },
    getTemplateFilesOptions: function() {
        return getTemplateFilesOptions;
    }
});
const _extends = require("@swc/helpers/_/_extends");
const _nodepath = require("node:path");
const _devkit = require("@nx/devkit");
const _artifactnameanddirectoryutils = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
const createAndUpdateGeneratorsJson = (tree, generator)=>{
    (0, _devkit.updateJson)(tree, generator.pkgFile, (json)=>{
        var _json;
        var _generators;
        (_generators = (_json = json).generators) != null ? _generators : _json.generators = "./generators.json";
        return json;
    });
    if (!generator.jsonExist) {
        (0, _devkit.writeJson)(tree, generator.jsonFile, {
            generators: {}
        });
    }
    const baseSrc = (0, _nodepath.join)(".", "src", "generators", generator.fileName);
    (0, _devkit.updateJson)(tree, generator.jsonFile, (json)=>{
        json.generators[generator.fileName] = {
            factory: (0, _nodepath.join)(baseSrc, "generator"),
            schema: (0, _nodepath.join)(baseSrc, "schema.json"),
            description: `${generator.name} generator`
        };
        return json;
    });
};
const getGeneratorInformation = async (tree, options)=>{
    var _generator_content_generators, _generator_content;
    // Get generator name
    const { name, fileName, propertyName, className } = (0, _devkit.names)(options.name);
    // Read plugin configuration
    const { name: pluginName, root: pluginRoot, sourceRoot: pluginSourceRoot } = (0, _devkit.readProjectConfiguration)(tree, options.plugin);
    const generator = getGeneratorJson(tree, pluginRoot);
    if ((generator == null ? void 0 : (_generator_content = generator.content) == null ? void 0 : (_generator_content_generators = _generator_content.generators) == null ? void 0 : _generator_content_generators[fileName]) !== undefined) {
        throw new Error(`Generator '${fileName}' existed on '${pluginName}'`);
    }
    // Build generator information
    const { directory } = await (0, _artifactnameanddirectoryutils.determineArtifactNameAndDirectoryOptions)(tree, {
        name: name,
        // name: pluginName,
        path: (0, _nodepath.join)(pluginSourceRoot, "generators", fileName)
    });
    return {
        pluginName,
        pluginRoot,
        pluginSourceRoot,
        name,
        fileName,
        propertyName,
        className,
        directory,
        pkgFile: generator == null ? void 0 : generator.pkgPath,
        jsonFile: generator == null ? void 0 : generator.filepath,
        jsonExist: generator == null ? void 0 : generator.fileExist
    };
};
const getTemplateFilesOptions = (generator, options)=>{
    return _extends._({
        name: options.name,
        description: options.description,
        plugin: options.plugin
    }, options.extra, {
        generator: {
            fnName: `${generator.propertyName}Generator`
        },
        schema: {
            id: generator.className,
            description: options.description,
            interface: `${generator.className}GeneratorSchema`
        }
    });
};
const getGeneratorJson = (tree, root)=>{
    var _packages_generators;
    const pkgPath = (0, _nodepath.join)(root, "package.json");
    if (!tree.exists(pkgPath)) return undefined;
    const packages = (0, _devkit.readJsonFile)(pkgPath);
    if (((_packages_generators = packages.generators) == null ? void 0 : _packages_generators.length) <= 0) {
        return undefined;
    }
    const filepath = (0, _nodepath.join)(root, packages.generators);
    if (!tree.exists(filepath)) return {
        fileExist: false,
        pkgPath,
        filepath,
        content: {}
    };
    const { generators } = (0, _devkit.readJsonFile)(filepath);
    return {
        fileExist: true,
        pkgPath,
        filepath,
        content: generators
    };
};

//# sourceMappingURL=generators.js.map