@nativescript/nx/src/utils/general.js

NativeScript Plugin for Nx

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.stringUtils = exports.sanitize = exports.supportedFrameworks = exports.supportedPlatforms = void 0;
exports.getPrefix = getPrefix;
exports.getFrontendFramework = getFrontendFramework;
exports.getGroupByName = getGroupByName;
exports.getBaseName = getBaseName;
exports.isXplatWorkspace = isXplatWorkspace;
exports.inferPluginSettingKey = inferPluginSettingKey;
exports.getDefaultTemplateOptions = getDefaultTemplateOptions;
exports.preRun = preRun;
exports.sanitizeCommaDelimitedArg = sanitizeCommaDelimitedArg;
exports.toFileName = toFileName;
const tslib_1 = require("tslib");
const devkit_1 = require("@nx/devkit");
const nxStringUtils = tslib_1.__importStar(require("@nx/devkit/src/utils/string-utils"));
const get_npm_scope_1 = require("@nx/js/src/utils/package-json/get-npm-scope");
const posix_1 = require("node:path/posix");
// TODO: support react, svelte, vue
// | 'react'
// | 'svelte
// | 'vue'
exports.supportedPlatforms = ['nativescript'];
exports.supportedFrameworks = ['angular']; //, 'react', 'svelte', 'vue']
// selector prefix to use when generating various boilerplate components
let prefix;
// user preferred default framework
let frontendFramework;
// Group by app name (appname-platform) instead of the default (platform-appname)
let groupByName = false;
let usingXplatWorkspace = false;
function getPrefix() {
    return prefix;
}
function getFrontendFramework() {
    return frontendFramework;
}
function getGroupByName() {
    return groupByName;
}
function getBaseName(options, platform) {
    const name = (0, posix_1.basename)((0, devkit_1.normalizePath)(options.directory));
    return groupByName ? name.replace(`-${platform}`, '') : name.replace(`${platform}-`, '');
}
function isXplatWorkspace() {
    return usingXplatWorkspace;
}
function inferPluginSettingKey() {
    return isXplatWorkspace() ? "xplat" /* WorkspaceSetting.XPLAT */ : "nativescript-nx" /* WorkspaceSetting.NATIVESCRIPT_NX */;
}
function getDefaultTemplateOptions(tree) {
    return {
        tmpl: '',
        utils: exports.stringUtils,
        npmScope: (0, get_npm_scope_1.getNpmScope)(tree),
        prefix: getPrefix(),
        dot: '.',
        standaloneAsDefault: false,
    };
}
function preRun(tree, options, init) {
    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
    const updatedCommonOptions = {
        prefix: options.prefix,
        framework: options.framework,
        groupByName: options.groupByName,
        isTesting: options.isTesting,
    };
    let frameworkChoice;
    if (options && options.framework) {
        // can actually specify comma-delimited list of frameworks to generate support for
        // most common to generate 1 at a time, but we allow multiple
        const frameworks = sanitizeCommaDelimitedArg(options.framework);
        // always default framework choice to first in list when multiple
        // when it's just one (most common) will be first already
        frameworkChoice = frameworks[0];
    }
    if (packageJson) {
        prefix = '';
        const pluginSettings = packageJson["nativescript-nx" /* WorkspaceSetting.NATIVESCRIPT_NX */] || packageJson["xplat" /* WorkspaceSetting.XPLAT */];
        if (pluginSettings) {
            usingXplatWorkspace = !!packageJson["xplat" /* WorkspaceSetting.XPLAT */];
            // use persisted settings
            prefix = pluginSettings.prefix || (0, get_npm_scope_1.getNpmScope)(tree); // (if not prefix, default to npmScope)
            frontendFramework = pluginSettings.framework;
            if (options) {
                if (options.prefix) {
                    // always use explicit prefix user passed in
                    prefix = options.prefix;
                }
                else {
                    // ensure options are updated
                    updatedCommonOptions.prefix = prefix;
                }
                if (frameworkChoice) {
                    // always override default framework when user has explicitly passed framework option in
                    frontendFramework = frameworkChoice;
                }
            }
            // grouping
            groupByName = pluginSettings.groupByName || (options ? options.groupByName : false);
        }
        else if (options) {
            groupByName = options.groupByName;
            if (options.prefix) {
                if (!prefix && init) {
                    // initializing for first time
                    prefix = options.prefix;
                }
            }
            else {
                // default to npmScope for prefix
                updatedCommonOptions.prefix = (0, get_npm_scope_1.getNpmScope)(tree);
            }
            if (frameworkChoice) {
                if (!frontendFramework && init) {
                    frontendFramework = frameworkChoice;
                }
            }
        }
    }
    return updatedCommonOptions;
}
function sanitizeCommaDelimitedArg(input) {
    if (input) {
        return input
            .split(',')
            .filter((i) => !!(i === null || i === void 0 ? void 0 : i.trim()))
            .map((i) => i.trim().toLowerCase());
    }
    return [];
}
/**
 * Sanitizes a given string by removing all characters that
 * are not letters or digits.
 *
 ```javascript
 sanitize('nativescript-app');  // 'nativescriptapp'
 sanitize('action_name');       // 'actioname'
 sanitize('css-class-name');    // 'cssclassname'
 sanitize('my favorite items'); // 'myfavoriteitems'
 ```

 @method sanitize
 @param {String} str The string to sanitize.
 @return {String} the sanitized string.
*/
const sanitize = (str) => str
    .split('')
    .filter((char) => /[a-zA-Z0-9]/.test(char))
    .join('');
exports.sanitize = sanitize;
function toFileName(s) {
    return s
        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
        .toLowerCase()
        .replace(/[ _]/g, '-');
}
exports.stringUtils = Object.assign({ sanitize: exports.sanitize }, nxStringUtils);
//# sourceMappingURL=general.js.map