@backstage/cli 0.30.0-next.2 → 0.30.0-next.3

package/dist/lib/new/preparation/collectPortableTemplateInput.cjs.js

@@ -0,0 +1,157 @@
+'use strict';
+
+var inquirer = require('inquirer');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var paths = require('../../paths.cjs.js');
+var resolvePackageParams = require('./resolvePackageParams.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+
+async function collectPortableTemplateInput(options) {
+  const { config, template, prefilledParams } = options;
+  const codeOwnersFilePath = await codeowners.getCodeownersFilePath(paths.paths.targetRoot);
+  const prompts = getPromptsForRole(template.role);
+  if (codeOwnersFilePath) {
+    prompts.push(ownerPrompt());
+  }
+  const deprecatedParams = {};
+  if (config.isUsingDefaultTemplates && prefilledParams.id) {
+    console.warn(
+      `DEPRECATION WARNING: The 'id' parameter is deprecated, use 'pluginId' instead`
+    );
+    deprecatedParams.pluginId = prefilledParams.id;
+  }
+  const parameters = {
+    ...template.values,
+    ...prefilledParams,
+    ...deprecatedParams
+  };
+  const needsAnswer = [];
+  const prefilledAnswers = {};
+  for (const prompt of prompts) {
+    if (prompt.name && parameters[prompt.name] !== void 0) {
+      prefilledAnswers[prompt.name] = parameters[prompt.name];
+    } else {
+      needsAnswer.push(prompt);
+    }
+  }
+  const promptAnswers = await inquirer__default.default.prompt(
+    needsAnswer
+  );
+  const answers = {
+    ...prefilledAnswers,
+    ...promptAnswers
+  };
+  const roleParams = {
+    role: template.role,
+    name: answers.name,
+    pluginId: answers.pluginId,
+    moduleId: answers.moduleId
+  };
+  const packageParams = resolvePackageParams.resolvePackageParams({
+    roleParams,
+    packagePrefix: config.packageNamePrefix,
+    pluginInfix: config.packageNamePluginInfix
+  });
+  return {
+    roleParams,
+    owner: answers.owner,
+    license: config.license,
+    version: config.version,
+    private: config.private,
+    publishRegistry: config.publishRegistry,
+    packageName: packageParams.packageName,
+    packagePath: packageParams.packagePath
+  };
+}
+function namePrompt() {
+  return {
+    type: "input",
+    name: "name",
+    message: "Enter the name of the package, without scope [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the name of the package";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Package names must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function pluginIdPrompt() {
+  return {
+    type: "input",
+    name: "pluginId",
+    message: "Enter the ID of the plugin [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the ID of the plugin";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Plugin IDs must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function moduleIdIdPrompt() {
+  return {
+    type: "input",
+    name: "moduleId",
+    message: "Enter the ID of the module [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the ID of the module";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Module IDs must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function getPromptsForRole(role) {
+  switch (role) {
+    case "web-library":
+    case "node-library":
+    case "common-library":
+      return [namePrompt()];
+    case "plugin-web-library":
+    case "plugin-node-library":
+    case "plugin-common-library":
+    case "frontend-plugin":
+    case "backend-plugin":
+      return [pluginIdPrompt()];
+    case "frontend-plugin-module":
+    case "backend-plugin-module":
+      return [pluginIdPrompt(), moduleIdIdPrompt()];
+    default:
+      return [];
+  }
+}
+function ownerPrompt() {
+  return {
+    type: "input",
+    name: "owner",
+    message: "Enter an owner to add to CODEOWNERS [optional]",
+    validate: (value) => {
+      if (!value) {
+        return true;
+      }
+      const ownerIds = codeowners.parseOwnerIds(value);
+      if (!ownerIds) {
+        return "The owner must be a space separated list of team names (e.g. @org/team-name), usernames (e.g. @username), or the email addresses (e.g. user@example.com).";
+      }
+      return true;
+    }
+  };
+}
+
+exports.collectPortableTemplateInput = collectPortableTemplateInput;
+exports.getPromptsForRole = getPromptsForRole;
+exports.moduleIdIdPrompt = moduleIdIdPrompt;
+exports.namePrompt = namePrompt;
+exports.ownerPrompt = ownerPrompt;
+exports.pluginIdPrompt = pluginIdPrompt;
+//# sourceMappingURL=collectPortableTemplateInput.cjs.js.map

package/dist/lib/new/preparation/loadPortableTemplate.cjs.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var z = require('zod');
+var fs = require('fs-extra');
+var recursiveReaddir = require('recursive-readdir');
+var path = require('path');
+var node_path = require('node:path');
+var yaml = require('yaml');
+var paths = require('../../paths.cjs.js');
+var types = require('../types.cjs.js');
+var errors = require('@backstage/errors');
+var zodValidationError = require('zod-validation-error');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var recursiveReaddir__default = /*#__PURE__*/_interopDefaultCompat(recursiveReaddir);
+
+const templateDefinitionSchema = z.z.object({
+  name: z.z.string(),
+  role: z.z.enum(types.TEMPLATE_ROLES),
+  description: z.z.string().optional(),
+  values: z.z.record(z.z.string()).optional()
+}).strict();
+async function loadPortableTemplate(pointer) {
+  if (pointer.target.match(/https?:\/\//)) {
+    throw new Error("Remote templates are not supported yet");
+  }
+  const templateContent = await fs__default.default.readFile(paths.paths.resolveTargetRoot(pointer.target), "utf-8").catch((error) => {
+    throw new errors.ForwardedError(
+      `Failed to load template definition from '${pointer.target}'`,
+      error
+    );
+  });
+  const rawTemplate = yaml.parse(templateContent);
+  const parsed = templateDefinitionSchema.safeParse(rawTemplate);
+  if (!parsed.success) {
+    throw new errors.ForwardedError(
+      `Invalid template definition at '${pointer.target}'`,
+      zodValidationError.fromZodError(parsed.error)
+    );
+  }
+  const { role, values = {} } = parsed.data;
+  const templatePath = path.resolve(node_path.dirname(pointer.target));
+  const filePaths = await recursiveReaddir__default.default(templatePath).catch((error) => {
+    throw new errors.ForwardedError(
+      `Failed to load template contents from '${templatePath}'`,
+      error
+    );
+  });
+  const loadedFiles = new Array();
+  for (const filePath of filePaths) {
+    const path$1 = path.relative(templatePath, filePath);
+    if (filePath === pointer.target) {
+      continue;
+    }
+    const content = await fs__default.default.readFile(filePath, "utf-8").catch((error) => {
+      throw new errors.ForwardedError(
+        `Failed to load file contents from '${path$1}'`,
+        error
+      );
+    });
+    if (path$1.endsWith(".hbs")) {
+      loadedFiles.push({
+        path: path$1.slice(0, -4),
+        content,
+        syntax: "handlebars"
+      });
+    } else {
+      loadedFiles.push({ path: path$1, content });
+    }
+  }
+  return {
+    name: pointer.name,
+    role,
+    files: loadedFiles,
+    values
+  };
+}
+
+exports.loadPortableTemplate = loadPortableTemplate;
+//# sourceMappingURL=loadPortableTemplate.cjs.js.map

package/dist/lib/new/preparation/loadPortableTemplateConfig.cjs.js

@@ -0,0 +1,121 @@
+'use strict';
+
+var fs = require('fs-extra');
+var node_path = require('node:path');
+var paths = require('../../paths.cjs.js');
+var defaultTemplates = require('../defaultTemplates.cjs.js');
+var types = require('../types.cjs.js');
+var yaml = require('yaml');
+var z = require('zod');
+var zodValidationError = require('zod-validation-error');
+var errors = require('@backstage/errors');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const defaults = {
+  license: "Apache-2.0",
+  version: "0.1.0",
+  private: true,
+  publishRegistry: void 0,
+  packageNamePrefix: "@internal/",
+  packageNamePluginInfix: "plugin-"
+};
+const newConfigSchema = z.z.object({
+  templates: z.z.array(z.z.string()).optional(),
+  globals: z.z.object({
+    license: z.z.string().optional(),
+    version: z.z.string().optional(),
+    private: z.z.boolean().optional(),
+    publishRegistry: z.z.string().optional(),
+    namePrefix: z.z.string().optional(),
+    namePluginInfix: z.z.string().optional()
+  }).optional()
+}).strict();
+const pkgJsonWithNewConfigSchema = z.z.object({
+  backstage: z.z.object({
+    cli: z.z.object({
+      new: newConfigSchema.optional()
+    }).optional()
+  }).optional()
+});
+async function loadPortableTemplateConfig(options = {}) {
+  const { overrides = {} } = options;
+  const pkgPath = options.packagePath ?? paths.paths.resolveTargetRoot("package.json");
+  const pkgJson = await fs__default.default.readJson(pkgPath);
+  const parsed = pkgJsonWithNewConfigSchema.safeParse(pkgJson);
+  if (!parsed.success) {
+    throw new errors.ForwardedError(
+      `Failed to load templating configuration from '${pkgPath}'`,
+      zodValidationError.fromZodError(parsed.error)
+    );
+  }
+  const config = parsed.data.backstage?.cli?.new;
+  const basePath = node_path.dirname(pkgPath);
+  const templatePointerEntries = await Promise.all(
+    (config?.templates ?? defaultTemplates.defaultTemplates).map(async (rawPointer) => {
+      try {
+        const templatePath = resolveLocalTemplatePath(rawPointer, basePath);
+        const pointer = await peekLocalTemplateDefinition(templatePath);
+        return { pointer, rawPointer };
+      } catch (error) {
+        throw new errors.ForwardedError(
+          `Failed to load template definition '${rawPointer}'`,
+          error
+        );
+      }
+    })
+  );
+  const templateNameConflicts = /* @__PURE__ */ new Map();
+  for (const { pointer, rawPointer } of templatePointerEntries) {
+    const conflict = templateNameConflicts.get(pointer.name);
+    if (conflict) {
+      throw new Error(
+        `Invalid template configuration, received conflicting template name '${pointer.name}' from '${conflict}' and '${rawPointer}'`
+      );
+    }
+    templateNameConflicts.set(pointer.name, rawPointer);
+  }
+  return {
+    isUsingDefaultTemplates: !config?.templates,
+    templatePointers: templatePointerEntries.map(({ pointer }) => pointer),
+    license: overrides.license ?? config?.globals?.license ?? defaults.license,
+    version: overrides.version ?? config?.globals?.version ?? defaults.version,
+    private: overrides.private ?? config?.globals?.private ?? defaults.private,
+    publishRegistry: overrides.publishRegistry ?? config?.globals?.publishRegistry ?? defaults.publishRegistry,
+    packageNamePrefix: overrides.packageNamePrefix ?? config?.globals?.namePrefix ?? defaults.packageNamePrefix,
+    packageNamePluginInfix: overrides.packageNamePluginInfix ?? config?.globals?.namePluginInfix ?? defaults.packageNamePluginInfix
+  };
+}
+function resolveLocalTemplatePath(pointer, basePath) {
+  if (node_path.isAbsolute(pointer)) {
+    throw new Error(`Template target may not be an absolute path`);
+  }
+  if (pointer.startsWith(".")) {
+    return node_path.resolve(basePath, pointer, types.TEMPLATE_FILE_NAME);
+  }
+  return require.resolve(`${pointer}/${types.TEMPLATE_FILE_NAME}`, {
+    paths: [basePath]
+  });
+}
+const partialTemplateDefinitionSchema = z.z.object({
+  name: z.z.string(),
+  description: z.z.string().optional()
+});
+async function peekLocalTemplateDefinition(target) {
+  const content = await fs__default.default.readFile(target, "utf8");
+  const rawTemplate = yaml.parse(content);
+  const parsed = partialTemplateDefinitionSchema.safeParse(rawTemplate);
+  if (!parsed.success) {
+    throw zodValidationError.fromZodError(parsed.error);
+  }
+  return {
+    name: parsed.data.name,
+    description: parsed.data.description,
+    target
+  };
+}
+
+exports.loadPortableTemplateConfig = loadPortableTemplateConfig;
+//# sourceMappingURL=loadPortableTemplateConfig.cjs.js.map

package/dist/lib/new/preparation/resolvePackageParams.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var path = require('path');
+
+function resolvePackageParams(options) {
+  const baseName = getBaseNameForRole(options.roleParams);
+  const isPlugin = options.roleParams.role.includes("plugin");
+  const pluginInfix = isPlugin ? options.pluginInfix : "";
+  return {
+    packageName: `${options.packagePrefix}${pluginInfix}${baseName}`,
+    packagePath: path.join(isPlugin ? "plugins" : "packages", baseName)
+  };
+}
+function getBaseNameForRole(roleParams) {
+  switch (roleParams.role) {
+    case "web-library":
+    case "node-library":
+    case "common-library":
+      return roleParams.name;
+    case "plugin-web-library":
+      return `${roleParams.pluginId}-react`;
+    case "plugin-node-library":
+      return `${roleParams.pluginId}-node`;
+    case "plugin-common-library":
+      return `${roleParams.pluginId}-common`;
+    case "frontend-plugin":
+      return `${roleParams.pluginId}`;
+    case "frontend-plugin-module":
+      return `${roleParams.pluginId}-module-${roleParams.moduleId}`;
+    case "backend-plugin":
+      return `${roleParams.pluginId}-backend`;
+    case "backend-plugin-module":
+      return `${roleParams.pluginId}-backend-module-${roleParams.moduleId}`;
+    default:
+      throw new Error(`Unknown role ${roleParams.role}`);
+  }
+}
+
+exports.resolvePackageParams = resolvePackageParams;
+//# sourceMappingURL=resolvePackageParams.cjs.js.map

package/dist/lib/new/preparation/selectTemplateInteractively.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var inquirer = require('inquirer');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+
+async function selectTemplateInteractively(config, preselectedTemplateName) {
+  let selectedName = preselectedTemplateName;
+  if (config.isUsingDefaultTemplates && selectedName === "plugin") {
+    console.warn(
+      `DEPRECATION WARNING: The 'plugin' template is deprecated, use 'frontend-plugin' instead`
+    );
+    selectedName = "frontend-plugin";
+  }
+  if (!selectedName) {
+    const answers = await inquirer__default.default.prompt([
+      {
+        type: "list",
+        name: "name",
+        message: "What do you want to create?",
+        choices: config.templatePointers.map(
+          (t) => t.description ? { name: `${t.name} - ${t.description}`, value: t.name } : t.name
+        )
+      }
+    ]);
+    selectedName = answers.name;
+  }
+  const template = config.templatePointers.find((t) => t.name === selectedName);
+  if (!template) {
+    throw new Error(`Template '${selectedName}' not found`);
+  }
+  return template;
+}
+
+exports.selectTemplateInteractively = selectTemplateInteractively;
+//# sourceMappingURL=selectTemplateInteractively.cjs.js.map

package/dist/lib/new/types.cjs.js

@@ -1,8 +1,19 @@
 'use strict';
 
-function createFactory(config) {
-  return config;
-}
+const TEMPLATE_FILE_NAME = "portable-template.yaml";
+const TEMPLATE_ROLES = [
+  "web-library",
+  "node-library",
+  "common-library",
+  "plugin-web-library",
+  "plugin-node-library",
+  "plugin-common-library",
+  "frontend-plugin",
+  "frontend-plugin-module",
+  "backend-plugin",
+  "backend-plugin-module"
+];
 
-exports.createFactory = createFactory;
+exports.TEMPLATE_FILE_NAME = TEMPLATE_FILE_NAME;
+exports.TEMPLATE_ROLES = TEMPLATE_ROLES;
 //# sourceMappingURL=types.cjs.js.map

package/dist/lib/tasks.cjs.js

@@ -1,23 +1,15 @@
 'use strict';
 
 var chalk = require('chalk');
-var fs = require('fs-extra');
-var handlebars = require('handlebars');
 var ora = require('ora');
 var util = require('util');
-var path = require('path');
-var recursive = require('recursive-readdir');
 var child_process = require('child_process');
 var errors = require('@backstage/errors');
-var paths = require('./paths.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
 var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
 var ora__default = /*#__PURE__*/_interopDefaultCompat(ora);
-var recursive__default = /*#__PURE__*/_interopDefaultCompat(recursive);
 
 const exec = util.promisify(child_process.exec);
 const TASK_NAME_MAX_LENGTH = 14;
@@ -80,109 +72,6 @@ ${chalk__default.default.red(message)}
     }
   }
 }
-async function templatingTask(templateDir, destinationDir, context, versionProvider, isMonoRepo) {
-  const files = await recursive__default.default(templateDir).catch((error) => {
-    throw new Error(`Failed to read template directory: ${error.message}`);
-  });
-  for (const file of files) {
-    const destinationFile = file.replace(templateDir, destinationDir);
-    await fs__default.default.ensureDir(path.dirname(destinationFile));
-    if (file.endsWith(".hbs")) {
-      await Task.forItem("templating", path.basename(file), async () => {
-        const destination = destinationFile.replace(/\.hbs$/, "");
-        const template = await fs__default.default.readFile(file);
-        const compiled = handlebars__default.default.compile(template.toString(), {
-          strict: true
-        });
-        const contents = compiled(
-          { name: path.basename(destination), ...context },
-          {
-            helpers: {
-              versionQuery(name, versionHint) {
-                return versionProvider(
-                  name,
-                  typeof versionHint === "string" ? versionHint : void 0
-                );
-              }
-            }
-          }
-        );
-        await fs__default.default.writeFile(destination, contents).catch((error) => {
-          throw new Error(
-            `Failed to create file: ${destination}: ${error.message}`
-          );
-        });
-      });
-    } else {
-      if (isMonoRepo && file.match("tsconfig.json")) {
-        continue;
-      }
-      await Task.forItem("copying", path.basename(file), async () => {
-        await fs__default.default.copyFile(file, destinationFile).catch((error) => {
-          const destination = destinationFile;
-          throw new Error(
-            `Failed to copy file to ${destination} : ${error.message}`
-          );
-        });
-      });
-    }
-  }
-}
-async function addPackageDependency(path, options) {
-  try {
-    const pkgJson = await fs__default.default.readJson(path);
-    const normalize = (obj) => {
-      if (Object.keys(obj).length === 0) {
-        return void 0;
-      }
-      return Object.fromEntries(
-        Object.keys(obj).sort().map((key) => [key, obj[key]])
-      );
-    };
-    pkgJson.dependencies = normalize({
-      ...pkgJson.dependencies,
-      ...options.dependencies
-    });
-    pkgJson.devDependencies = normalize({
-      ...pkgJson.devDependencies,
-      ...options.devDependencies
-    });
-    pkgJson.peerDependencies = normalize({
-      ...pkgJson.peerDependencies,
-      ...options.peerDependencies
-    });
-    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
-  } catch (error) {
-    throw new Error(`Failed to add package dependencies, ${error}`);
-  }
-}
-async function addToBackend(name, options) {
-  if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
-    await Task.forItem("backend", `adding ${options.type}`, async () => {
-      const backendFilePath = paths.paths.resolveTargetRoot(
-        "packages/backend/src/index.ts"
-      );
-      if (!await fs__default.default.pathExists(backendFilePath)) {
-        return;
-      }
-      const content = await fs__default.default.readFile(backendFilePath, "utf8");
-      const lines = content.split("\n");
-      const backendAddLine = `backend.add(import('${name}'));`;
-      const backendStartIndex = lines.findIndex(
-        (line) => line.match(/backend.start/)
-      );
-      if (backendStartIndex !== -1) {
-        const [indentation] = lines[backendStartIndex].match(/^\s*/);
-        lines.splice(backendStartIndex, 0, `${indentation}${backendAddLine}`);
-        const newContent = lines.join("\n");
-        await fs__default.default.writeFile(backendFilePath, newContent, "utf8");
-      }
-    });
-  }
-}
 
 exports.Task = Task;
-exports.addPackageDependency = addPackageDependency;
-exports.addToBackend = addToBackend;
-exports.templatingTask = templatingTask;
 //# sourceMappingURL=tasks.cjs.js.map

package/dist/packages/backend-defaults/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "0.8.0-next.2";
+var version = "0.8.0-next.3";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/packages/backend-plugin-api/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "1.2.0-next.1";
+var version = "1.2.0-next.2";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/packages/backend-test-utils/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "1.3.0-next.2";
+var version = "1.3.0-next.3";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/packages/cli/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "0.30.0-next.2";
+var version = "0.30.0-next.3";
 var dependencies = {
 	"@backstage/catalog-model": "workspace:^",
 	"@backstage/cli-common": "workspace:^",
@@ -114,7 +114,8 @@ var dependencies = {
 	yargs: "^16.2.0",
 	"yml-loader": "^2.1.0",
 	yn: "^4.0.0",
-	zod: "^3.22.4"
+	zod: "^3.22.4",
+	"zod-validation-error": "^3.4.0"
 };
 var devDependencies = {
 	"@backstage/backend-plugin-api": "workspace:^",

package/dist/packages/dev-utils/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "1.1.7-next.2";
+var version = "1.1.7-next.3";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/plugins/auth-backend/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "0.24.3-next.2";
+var version = "0.24.3-next.3";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/plugins/auth-backend-module-guest-provider/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "0.2.5-next.1";
+var version = "0.2.5-next.2";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map

package/dist/plugins/catalog-node/package.json.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "1.16.0-next.2";
+var version = "1.16.0-next.3";
 
 exports.version = version;
 //# sourceMappingURL=package.json.cjs.js.map