@grafana/create-plugin 2.11.2 → 2.12.0-canary.658.dabaee1.0

package/dist/utils/utils.npm.js

@@ -1,92 +1,60 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanUpPackageJson = exports.writePackageManagerInPackageJson = exports.updateNpmScripts = exports.removeNpmDependencies = exports.getRemovableNpmDependencies = exports.getUpdatableNpmDependencies = exports.getPackageJsonUpdates = exports.updateNpmDependencies = exports.updatePackageJson = exports.hasNpmDependenciesToUpdate = exports.getPackageJsonUpdatesAsText = exports.getNpmDependencyUpdatesAsText = void 0;
-var semver_1 = __importDefault(require("semver"));
-var constants_1 = require("../constants");
-var utils_packagejson_1 = require("./utils.packagejson");
-function getNpmDependencyUpdatesAsText(dependencyUpdates) {
+import semver from 'semver';
+import { GRAFANA_FE_PACKAGES } from '../constants.js';
+import { getPackageJson, writePackageJson, getLatestPackageJson } from './utils.packagejson.js';
+export function getNpmDependencyUpdatesAsText(dependencyUpdates) {
     return Object.entries(dependencyUpdates)
-        .filter(function (_a) {
-        var packageName = _a[0], _b = _a[1], prev = _b.prev, next = _b.next;
-        return prev !== next;
-    })
-        .map(function (_a) {
-        var packageName = _a[0], _b = _a[1], prev = _b.prev, next = _b.next;
+        .filter(([packageName, { prev, next }]) => prev !== next)
+        .map(([packageName, { prev, next }]) => {
         if (!prev) {
-            return "`".concat(packageName, "` - `").concat(next, "` (new)");
+            return `\`${packageName}\` - \`${next}\` (new)`;
         }
-        return "`".concat(packageName, "` - `").concat(prev, "` -> `").concat(next, "` (updated)");
+        return `\`${packageName}\` - \`${prev}\` -> \`${next}\` (updated)`;
     })
         .join('\n  ');
 }
-exports.getNpmDependencyUpdatesAsText = getNpmDependencyUpdatesAsText;
-function getPackageJsonUpdatesAsText(options) {
-    if (options === void 0) { options = {}; }
-    var asText = '';
-    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
-    var npmDependencyUpdatesText = getNpmDependencyUpdatesAsText(dependencyUpdates);
-    var npmDevDependencyUpdatesText = getNpmDependencyUpdatesAsText(devDependencyUpdates);
+export function getPackageJsonUpdatesAsText(options = {}) {
+    let asText = '';
+    const { dependencyUpdates, devDependencyUpdates } = getPackageJsonUpdates(options);
+    const npmDependencyUpdatesText = getNpmDependencyUpdatesAsText(dependencyUpdates);
+    const npmDevDependencyUpdatesText = getNpmDependencyUpdatesAsText(devDependencyUpdates);
     if (npmDependencyUpdatesText.length > 0) {
-        asText += "\n\n  **Dependencies**\n  ".concat(getNpmDependencyUpdatesAsText(dependencyUpdates));
+        asText += `\n\n  **Dependencies**\n  ${getNpmDependencyUpdatesAsText(dependencyUpdates)}`;
     }
     if (npmDevDependencyUpdatesText.length > 0) {
-        asText += "\n\n  **Dev Dependencies**\n  ".concat(getNpmDependencyUpdatesAsText(devDependencyUpdates));
+        asText += `\n\n  **Dev Dependencies**\n  ${getNpmDependencyUpdatesAsText(devDependencyUpdates)}`;
     }
     return asText;
 }
-exports.getPackageJsonUpdatesAsText = getPackageJsonUpdatesAsText;
-function hasNpmDependenciesToUpdate(options) {
-    if (options === void 0) { options = {}; }
-    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
+export function hasNpmDependenciesToUpdate(options = {}) {
+    const { dependencyUpdates, devDependencyUpdates } = getPackageJsonUpdates(options);
     return Object.keys(dependencyUpdates).length > 0 || Object.keys(devDependencyUpdates).length > 0;
 }
-exports.hasNpmDependenciesToUpdate = hasNpmDependenciesToUpdate;
-function updatePackageJson(options) {
-    if (options === void 0) { options = {}; }
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
-    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
+export function updatePackageJson(options = {}) {
+    const packageJson = getPackageJson();
+    const { dependencyUpdates, devDependencyUpdates } = getPackageJsonUpdates(options);
     packageJson.dependencies = updateNpmDependencies(packageJson.dependencies, dependencyUpdates);
     packageJson.devDependencies = updateNpmDependencies(packageJson.devDependencies, devDependencyUpdates);
-    (0, utils_packagejson_1.writePackageJson)(packageJson);
+    writePackageJson(packageJson);
 }
-exports.updatePackageJson = updatePackageJson;
-function updateNpmDependencies(dependencies, updateSummary) {
-    var updatedDependencies = __assign({}, dependencies);
-    for (var _i = 0, _a = Object.entries(updateSummary); _i < _a.length; _i++) {
-        var _b = _a[_i], packageName = _b[0], summary = _b[1];
+export function updateNpmDependencies(dependencies, updateSummary) {
+    const updatedDependencies = { ...dependencies };
+    for (const [packageName, summary] of Object.entries(updateSummary)) {
         updatedDependencies[packageName] = summary.next;
     }
     return updatedDependencies;
 }
-exports.updateNpmDependencies = updateNpmDependencies;
-function getPackageJsonUpdates(options) {
-    if (options === void 0) { options = {}; }
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
-    var newPackageJson = (0, utils_packagejson_1.getLatestPackageJson)();
-    var dependencies = packageJson.dependencies || {};
-    var devDependencies = packageJson.devDependencies || {};
-    var newDependencies = newPackageJson.dependencies || {};
-    var newDevDependencies = newPackageJson.devDependencies || {};
-    var dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
-    var devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
+export function getPackageJsonUpdates(options = {}) {
+    const packageJson = getPackageJson();
+    const newPackageJson = getLatestPackageJson();
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const newDependencies = newPackageJson.dependencies || {};
+    const newDevDependencies = newPackageJson.devDependencies || {};
+    let dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
+    let devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
     if (options.ignoreGrafanaDependencies) {
-        var prevGrafanaDependencies = Object.entries(__assign(__assign({}, dependencies), devDependencies)).reduce(function (acc, _a) {
-            var key = _a[0], value = _a[1];
-            if (constants_1.GRAFANA_FE_PACKAGES.includes(key)) {
+        const prevGrafanaDependencies = Object.entries({ ...dependencies, ...devDependencies }).reduce((acc, [key, value]) => {
+            if (GRAFANA_FE_PACKAGES.includes(key)) {
                 acc[key] = value;
             }
             return acc;
@@ -96,14 +64,12 @@ function getPackageJsonUpdates(options) {
     }
     return {
         dependencyUpdates: options.devOnly ? {} : dependencyUpdates,
-        devDependencyUpdates: devDependencyUpdates,
+        devDependencyUpdates,
     };
 }
-exports.getPackageJsonUpdates = getPackageJsonUpdates;
 function ignoreGrafanaDependencies(dependencyUpdates, prevGrafanaDependencies) {
-    var whatever = Object.keys(prevGrafanaDependencies);
-    var result = Object.entries(dependencyUpdates).reduce(function (acc, _a) {
-        var packageName = _a[0], value = _a[1];
+    const whatever = Object.keys(prevGrafanaDependencies);
+    const result = Object.entries(dependencyUpdates).reduce((acc, [packageName, value]) => {
         if (whatever.includes(packageName)) {
             acc[packageName] = {
                 prev: prevGrafanaDependencies[packageName],
@@ -117,12 +83,10 @@ function ignoreGrafanaDependencies(dependencyUpdates, prevGrafanaDependencies) {
     }, {});
     return result;
 }
-function getUpdatableNpmDependencies(prevDeps, nextDeps, options) {
-    if (options === void 0) { options = {}; }
-    var updateSummary = {};
-    for (var _i = 0, _a = Object.entries(nextDeps); _i < _a.length; _i++) {
-        var _b = _a[_i], packageName = _b[0], newSemverRange = _b[1];
-        var currentSemverRange = prevDeps[packageName];
+export function getUpdatableNpmDependencies(prevDeps, nextDeps, options = {}) {
+    const updateSummary = {};
+    for (const [packageName, newSemverRange] of Object.entries(nextDeps)) {
+        const currentSemverRange = prevDeps[packageName];
         if (!currentSemverRange) {
             updateSummary[packageName] = { prev: null, next: newSemverRange };
             continue;
@@ -130,82 +94,75 @@ function getUpdatableNpmDependencies(prevDeps, nextDeps, options) {
         if (newSemverRange === currentSemverRange) {
             continue;
         }
-        if (!semver_1.default.validRange(newSemverRange) || !semver_1.default.validRange(currentSemverRange)) {
+        if (!semver.validRange(newSemverRange) || !semver.validRange(currentSemverRange)) {
             updateSummary[packageName] = { prev: currentSemverRange, next: newSemverRange };
             continue;
         }
-        var newSemverVersion = semver_1.default.minVersion(newSemverRange);
-        var currentSemverVersion = semver_1.default.minVersion(currentSemverRange);
-        if (!newSemverVersion || !semver_1.default.valid(newSemverVersion)) {
-            console.warn("Skipping: invalid new semver version \"".concat(newSemverRange, "\" for \"").concat(packageName, "\""));
+        const newSemverVersion = semver.minVersion(newSemverRange);
+        const currentSemverVersion = semver.minVersion(currentSemverRange);
+        if (!newSemverVersion || !semver.valid(newSemverVersion)) {
+            console.warn(`Skipping: invalid new semver version "${newSemverRange}" for "${packageName}"`);
             continue;
         }
-        if (!currentSemverVersion || !semver_1.default.valid(currentSemverVersion)) {
-            console.warn("Skipping: invalid current semver version \"".concat(currentSemverRange, "\" for \"").concat(packageName, "\""));
+        if (!currentSemverVersion || !semver.valid(currentSemverVersion)) {
+            console.warn(`Skipping: invalid current semver version "${currentSemverRange}" for "${packageName}"`);
             continue;
         }
-        if (!options.onlyOutdated || semver_1.default.gte(newSemverVersion, currentSemverVersion)) {
+        if (!options.onlyOutdated || semver.gte(newSemverVersion, currentSemverVersion)) {
             updateSummary[packageName] = { prev: currentSemverRange, next: newSemverRange };
             continue;
         }
     }
     return updateSummary;
 }
-exports.getUpdatableNpmDependencies = getUpdatableNpmDependencies;
-function getRemovableNpmDependencies(packageNames) {
-    var _a = (0, utils_packagejson_1.getPackageJson)(), _b = _a.dependencies, dependencies = _b === void 0 ? {} : _b, _c = _a.devDependencies, devDependencies = _c === void 0 ? {} : _c;
-    return packageNames.filter(function (packageName) { return dependencies[packageName] || devDependencies[packageName]; });
+export function getRemovableNpmDependencies(packageNames) {
+    const { dependencies = {}, devDependencies = {} } = getPackageJson();
+    return packageNames.filter((packageName) => dependencies[packageName] || devDependencies[packageName]);
 }
-exports.getRemovableNpmDependencies = getRemovableNpmDependencies;
-function removeNpmDependencies(packageNames, _a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.devOnly, devOnly = _c === void 0 ? false : _c;
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
-    for (var _i = 0, packageNames_1 = packageNames; _i < packageNames_1.length; _i++) {
-        var packageName = packageNames_1[_i];
+export function removeNpmDependencies(packageNames, { devOnly = false } = {}) {
+    const packageJson = getPackageJson();
+    for (const packageName of packageNames) {
         if (!devOnly) {
             delete packageJson.dependencies[packageName];
         }
         delete packageJson.devDependencies[packageName];
     }
-    (0, utils_packagejson_1.writePackageJson)(packageJson);
+    writePackageJson(packageJson);
 }
-exports.removeNpmDependencies = removeNpmDependencies;
-function updateNpmScripts() {
-    var toolkitScriptRe = /grafana-toolkit plugin:.*/;
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
-    var latestPackageJson = (0, utils_packagejson_1.getLatestPackageJson)();
-    var scripts = __assign(__assign({}, packageJson.scripts), latestPackageJson.scripts);
-    for (var _i = 0, _a = Object.keys(scripts); _i < _a.length; _i++) {
-        var key = _a[_i];
+export function updateNpmScripts() {
+    const toolkitScriptRe = /grafana-toolkit plugin:.*/;
+    const packageJson = getPackageJson();
+    const latestPackageJson = getLatestPackageJson();
+    const scripts = {
+        ...packageJson.scripts,
+        ...latestPackageJson.scripts,
+    };
+    for (const key of Object.keys(scripts)) {
         if (toolkitScriptRe.test(scripts[key])) {
             delete scripts[key];
         }
     }
     packageJson.scripts = scripts;
-    (0, utils_packagejson_1.writePackageJson)(packageJson);
+    writePackageJson(packageJson);
 }
-exports.updateNpmScripts = updateNpmScripts;
-function writePackageManagerInPackageJson(_a) {
-    var packageManagerName = _a.packageManagerName, packageManagerVersion = _a.packageManagerVersion;
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
+export function writePackageManagerInPackageJson({ packageManagerName, packageManagerVersion }) {
+    const packageJson = getPackageJson();
     if (!packageJson.packageManager) {
-        packageJson.packageManager = "".concat(packageManagerName, "@").concat(packageManagerVersion);
-        (0, utils_packagejson_1.writePackageJson)(packageJson);
+        packageJson.packageManager = `${packageManagerName}@${packageManagerVersion}`;
+        writePackageJson(packageJson);
     }
 }
-exports.writePackageManagerInPackageJson = writePackageManagerInPackageJson;
-function cleanUpPackageJson() {
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
+export function cleanUpPackageJson() {
+    const packageJson = getPackageJson();
     packageJson.scripts = sortKeysAlphabetically(packageJson.scripts);
     packageJson.dependencies = sortKeysAlphabetically(packageJson.dependencies);
     packageJson.devDependencies = sortKeysAlphabetically(packageJson.devDependencies);
-    (0, utils_packagejson_1.writePackageJson)(packageJson);
+    writePackageJson(packageJson);
 }
-exports.cleanUpPackageJson = cleanUpPackageJson;
 function sortKeysAlphabetically(obj) {
     return Object.keys(obj)
         .sort()
-        .reduce(function (acc, key) {
+        .reduce((acc, key) => {
         acc[key] = obj[key];
         return acc;
     }, {});

package/dist/utils/utils.os.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUnsupportedPlatform = void 0;
-var os_1 = require("os");
-function isUnsupportedPlatform() {
-    var os = (0, os_1.platform)();
+import { platform } from 'os';
+export function isUnsupportedPlatform() {
+    const os = platform();
     if (os === 'win32') {
         return true;
     }
     return false;
 }
-exports.isUnsupportedPlatform = isUnsupportedPlatform;

package/dist/utils/utils.packageManager.js

@@ -1,41 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageManagerInstallCmd = exports.getPackageManagerWithFallback = exports.getPackageManagerFromUserAgent = void 0;
-var path_1 = require("path");
-var child_process_1 = require("child_process");
-var find_up_1 = require("find-up");
-var utils_packagejson_1 = require("./utils.packagejson");
-var NPM_LOCKFILE = 'package-lock.json';
-var PNPM_LOCKFILE = 'pnpm-lock.yaml';
-var YARN_LOCKFILE = 'yarn.lock';
-var SUPPORTED_PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm'];
-var DEFAULT_PACKAGE_MANAGER = { packageManagerName: 'yarn', packageManagerVersion: '1.22.19' };
-function getPackageManagerFromUserAgent() {
-    var agent = process.env.npm_config_user_agent;
+import { basename } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { sync as findUpSync } from 'find-up';
+import { getPackageJson } from './utils.packagejson.js';
+const NPM_LOCKFILE = 'package-lock.json';
+const PNPM_LOCKFILE = 'pnpm-lock.yaml';
+const YARN_LOCKFILE = 'yarn.lock';
+const SUPPORTED_PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm'];
+const DEFAULT_PACKAGE_MANAGER = { packageManagerName: 'yarn', packageManagerVersion: '1.22.19' };
+export function getPackageManagerFromUserAgent() {
+    const agent = process.env.npm_config_user_agent;
     if (!agent) {
         return DEFAULT_PACKAGE_MANAGER;
     }
-    var _a = agent.split('/'), name = _a[0], versionWithText = _a[1];
-    var version = versionWithText.split(' ')[0];
+    const [name, versionWithText] = agent.split('/');
+    const [version] = versionWithText.split(' ');
     if (SUPPORTED_PACKAGE_MANAGERS.includes(name)) {
         return { packageManagerName: name, packageManagerVersion: version.trimEnd() };
     }
     return DEFAULT_PACKAGE_MANAGER;
 }
-exports.getPackageManagerFromUserAgent = getPackageManagerFromUserAgent;
-function getPackageManagerWithFallback() {
-    var packageManagerFromPackageJson = getPackageManagerFromPackageJson();
+export function getPackageManagerWithFallback() {
+    const packageManagerFromPackageJson = getPackageManagerFromPackageJson();
     if (packageManagerFromPackageJson) {
         return packageManagerFromPackageJson;
     }
-    var packageManagerFromLockFile = getPackageManagerFromLockFile();
+    const packageManagerFromLockFile = getPackageManagerFromLockFile();
     if (packageManagerFromLockFile) {
         return packageManagerFromLockFile;
     }
     return DEFAULT_PACKAGE_MANAGER;
 }
-exports.getPackageManagerWithFallback = getPackageManagerWithFallback;
-function getPackageManagerInstallCmd(packageManagerName) {
+export function getPackageManagerInstallCmd(packageManagerName) {
     switch (packageManagerName) {
         case 'yarn':
             return 'yarn install --immutable --prefer-offline';
@@ -45,34 +40,33 @@ function getPackageManagerInstallCmd(packageManagerName) {
             return 'npm ci';
     }
 }
-exports.getPackageManagerInstallCmd = getPackageManagerInstallCmd;
 function getPackageManagerFromLockFile() {
-    var closestLockfilePath = (0, find_up_1.sync)([YARN_LOCKFILE, PNPM_LOCKFILE, NPM_LOCKFILE]);
+    const closestLockfilePath = findUpSync([YARN_LOCKFILE, PNPM_LOCKFILE, NPM_LOCKFILE]);
     if (!Boolean(closestLockfilePath)) {
         return undefined;
     }
-    var closestLockfile = closestLockfilePath && (0, path_1.basename)(closestLockfilePath);
+    const closestLockfile = closestLockfilePath && basename(closestLockfilePath);
     try {
         if (closestLockfile === NPM_LOCKFILE) {
-            var npmVersionCommand = (0, child_process_1.spawnSync)('npm', ['--version'], {
+            const npmVersionCommand = spawnSync('npm', ['--version'], {
                 shell: true,
             });
-            var packageManagerVersion = npmVersionCommand.stdout.toString().trimEnd();
-            return { packageManagerName: 'npm', packageManagerVersion: packageManagerVersion };
+            const packageManagerVersion = npmVersionCommand.stdout.toString().trimEnd();
+            return { packageManagerName: 'npm', packageManagerVersion };
         }
         if (closestLockfile === PNPM_LOCKFILE) {
-            var pnpmVersionCommand = (0, child_process_1.spawnSync)('pnpm', ['--version'], {
+            const pnpmVersionCommand = spawnSync('pnpm', ['--version'], {
                 shell: true,
             });
-            var packageManagerVersion = pnpmVersionCommand.stdout.toString().trimEnd();
-            return { packageManagerName: 'pnpm', packageManagerVersion: packageManagerVersion };
+            const packageManagerVersion = pnpmVersionCommand.stdout.toString().trimEnd();
+            return { packageManagerName: 'pnpm', packageManagerVersion };
         }
         if (closestLockfile === YARN_LOCKFILE) {
-            var yarnVersionCommand = (0, child_process_1.spawnSync)('yarn', ['--version'], {
+            const yarnVersionCommand = spawnSync('yarn', ['--version'], {
                 shell: true,
             });
-            var packageManagerVersion = yarnVersionCommand.stdout.toString().trimEnd();
-            return { packageManagerName: 'yarn', packageManagerVersion: packageManagerVersion };
+            const packageManagerVersion = yarnVersionCommand.stdout.toString().trimEnd();
+            return { packageManagerName: 'yarn', packageManagerVersion };
         }
         return undefined;
     }
@@ -82,10 +76,10 @@ function getPackageManagerFromLockFile() {
     }
 }
 function getPackageManagerFromPackageJson() {
-    var packageJson = (0, utils_packagejson_1.getPackageJson)();
+    const packageJson = getPackageJson();
     if (packageJson.hasOwnProperty('packageManager')) {
-        var _a = packageJson.packageManager.split('@'), packageManagerName = _a[0], packageManagerVersion = _a[1];
-        return { packageManagerName: packageManagerName, packageManagerVersion: packageManagerVersion };
+        const [packageManagerName, packageManagerVersion] = packageJson.packageManager.split('@');
+        return { packageManagerName, packageManagerVersion };
     }
     return undefined;
 }

package/dist/utils/utils.packagejson.js

@@ -1,25 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writePackageJson = exports.getLatestPackageJson = exports.getPackageJson = void 0;
-var path_1 = __importDefault(require("path"));
-var constants_1 = require("../constants");
-var utils_files_1 = require("./utils.files");
-var utils_templates_1 = require("./utils.templates");
-var fs_1 = __importDefault(require("fs"));
-function getPackageJson() {
-    return (0, utils_files_1.readJsonFile)(path_1.default.join(process.cwd(), 'package.json'));
+import path from 'node:path';
+import { TEMPLATE_PATHS } from '../constants.js';
+import { readJsonFile } from './utils.files.js';
+import { getTemplateData, renderTemplateFromFile } from './utils.templates.js';
+import fs from 'node:fs';
+export function getPackageJson() {
+    return readJsonFile(path.join(process.cwd(), 'package.json'));
 }
-exports.getPackageJson = getPackageJson;
-function getLatestPackageJson() {
-    var packageJsonPath = path_1.default.join(constants_1.TEMPLATE_PATHS.common, '_package.json');
-    var data = (0, utils_templates_1.getTemplateData)();
-    return JSON.parse((0, utils_templates_1.renderTemplateFromFile)(packageJsonPath, data));
+export function getLatestPackageJson() {
+    const packageJsonPath = path.join(TEMPLATE_PATHS.common, '_package.json');
+    const data = getTemplateData();
+    return JSON.parse(renderTemplateFromFile(packageJsonPath, data));
 }
-exports.getLatestPackageJson = getLatestPackageJson;
-function writePackageJson(json) {
-    return fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'package.json'), "".concat(JSON.stringify(json, null, 2), "\n"));
+export function writePackageJson(json) {
+    return fs.writeFileSync(path.join(process.cwd(), 'package.json'), `${JSON.stringify(json, null, 2)}\n`);
 }
-exports.writePackageJson = writePackageJson;

package/dist/utils/utils.path.js

@@ -1,18 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExportPath = void 0;
-var path_1 = __importDefault(require("path"));
-var constants_1 = require("../constants");
-var utils_handlebars_1 = require("./utils.handlebars");
-function getExportPath(pluginName, orgName, pluginType) {
-    if (constants_1.IS_DEV) {
-        return constants_1.DEV_EXPORT_DIR;
+import path from 'node:path';
+import { IS_DEV, DEV_EXPORT_DIR } from '../constants.js';
+import { normalizeId } from './utils.handlebars.js';
+export function getExportPath(pluginName, orgName, pluginType) {
+    if (IS_DEV) {
+        return DEV_EXPORT_DIR;
     }
     else {
-        return path_1.default.join(process.cwd(), (0, utils_handlebars_1.normalizeId)(pluginName, orgName, pluginType));
+        return path.join(process.cwd(), normalizeId(pluginName, orgName, pluginType));
     }
 }
-exports.getExportPath = getExportPath;

package/dist/utils/utils.plugin.js

@@ -1,14 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPluginJson = void 0;
-var path_1 = __importDefault(require("path"));
-var utils_files_1 = require("./utils.files");
-function getPluginJson(srcDir) {
-    var srcPath = srcDir || path_1.default.join(process.cwd(), 'src');
-    var pluginJsonPath = path_1.default.join(srcPath, 'plugin.json');
-    return (0, utils_files_1.readJsonFile)(pluginJsonPath);
+import path from 'node:path';
+import { readJsonFile } from './utils.files.js';
+export function getPluginJson(srcDir) {
+    const srcPath = srcDir || path.join(process.cwd(), 'src');
+    const pluginJsonPath = path.join(srcPath, 'plugin.json');
+    return readJsonFile(pluginJsonPath);
 }
-exports.getPluginJson = getPluginJson;