@aussieljk/forkbook 0.0.0-stage → 0.0.1-10

package/dist/_node-chunks/chunk-RJXAXHDJ.js

@@ -0,0 +1,415 @@
+import CJS_COMPAT_NODE_URL_upaeg5sjpn from 'node:url';
+import CJS_COMPAT_NODE_PATH_upaeg5sjpn from 'node:path';
+import CJS_COMPAT_NODE_MODULE_upaeg5sjpn from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_upaeg5sjpn.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_upaeg5sjpn.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_upaeg5sjpn.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  DOCUMENTATION_LINK
+} from "./chunk-YU5TVYPS.js";
+import {
+  any
+} from "./chunk-G2ZUFOHU.js";
+
+// src/addon-vitest/postinstall.ts
+import * as fs from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
+import os from "node:os";
+import { babelParse, generate, traverse } from "@aussieljk/forkbook/internal/babel";
+import { AddonVitestService } from "@aussieljk/forkbook/internal/cli";
+import {
+  JsPackageManagerFactory,
+  formatFileContent,
+  getProjectRoot,
+  getStorybookInfo
+} from "@aussieljk/forkbook/internal/common";
+import { CLI_COLORS } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  AddonVitestPostinstallConfigUpdateError,
+  AddonVitestPostinstallError,
+  AddonVitestPostinstallPrerequisiteCheckError
+} from "@aussieljk/forkbook/internal/server-errors";
+import { dirname, relative, resolve } from "pathe";
+import { dedent } from "ts-dedent";
+
+// src/addon-vitest/updateVitestFile.ts
+import {
+  getConfigObjectFromMergeArg,
+  getEffectiveMergeConfigCall,
+  getTargetConfigObject,
+  isDefineConfigLike,
+  resolveExpression
+} from "@aussieljk/forkbook/internal/babel";
+import { normalize } from "pathe";
+async function getTemplatePath() {
+  return import("./vitest.config.4.template-74HEE4WJ.js");
+}
+var loadTemplate = async (name, replacements) => {
+  let template = (await getTemplatePath()).default;
+  return Object.entries(replacements).forEach(
+    ([key, value]) => template = template.replace(key, normalize(value))
+  ), template;
+}, mergeProperties = (source, target) => {
+  for (let sourceProp of source)
+    if (sourceProp.type === "ObjectProperty") {
+      let targetProp = target.find(
+        (p) => sourceProp.key.type === "Identifier" && p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === sourceProp.key.name
+      );
+      targetProp && targetProp.type === "ObjectProperty" ? sourceProp.value.type === "ObjectExpression" && targetProp.value.type === "ObjectExpression" ? mergeProperties(sourceProp.value.properties, targetProp.value.properties) : sourceProp.value.type === "ArrayExpression" && targetProp.value.type === "ArrayExpression" ? targetProp.value.elements.push(...sourceProp.value.elements) : targetProp.value = sourceProp.value : target.push(sourceProp);
+    }
+}, resolveTestPropValue = (testProp, ast) => {
+  if (testProp.value.type === "ObjectExpression")
+    return testProp.value;
+  let resolved = resolveExpression(testProp.value, ast);
+  return resolved?.type === "ObjectExpression" ? resolved : null;
+}, findNamedProp = (properties, name) => properties.find(
+  (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === name
+), isProjectsArrayProp = (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "projects" && p.value.type === "ArrayExpression", appendToExistingProjectRefs = (existingProjectRefsProp, resolvedTestValue, templateTestProp, properties, targetConfigObject) => {
+  if (templateTestProp && templateTestProp.value.type === "ObjectExpression") {
+    let templateProjectRefsProp = templateTestProp.value.properties.find(
+      (p) => isProjectsArrayProp(p)
+    );
+    templateProjectRefsProp && templateProjectRefsProp.value.type === "ArrayExpression" && existingProjectRefsProp.value.elements.push(
+      ...templateProjectRefsProp.value.elements
+    );
+    let existingTestPropNames = new Set(
+      resolvedTestValue.properties.filter(
+        (p) => p.type === "ObjectProperty" && p.key.type === "Identifier"
+      ).map((p) => p.key.name)
+    );
+    for (let templateProp of templateTestProp.value.properties)
+      templateProp.type === "ObjectProperty" && templateProp.key.type === "Identifier" && templateProp.key.name !== "projects" && !existingTestPropNames.has(templateProp.key.name) && resolvedTestValue.properties.push(templateProp);
+  }
+  let otherTemplateProps = properties.filter(
+    (p) => !(p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test")
+  );
+  otherTemplateProps.length > 0 && mergeProperties(otherTemplateProps, targetConfigObject.properties);
+}, wrapTestConfigAsProject = (resolvedTestValue, existingTestProp, templateTestProp, properties, targetConfigObject) => {
+  let projectsProp = templateTestProp.value.type === "ObjectExpression" ? templateTestProp.value.properties.find((p) => isProjectsArrayProp(p)) : void 0;
+  if (!projectsProp || projectsProp.value.type !== "ArrayExpression") {
+    mergeProperties(properties, targetConfigObject.properties);
+    return;
+  }
+  let topLevelProps = [
+    "shard",
+    "watch",
+    "run",
+    "cache",
+    "update",
+    "reporters",
+    "outputFile",
+    "teardownTimeout",
+    "silent",
+    "forceRerunTriggers",
+    "testNamePattern",
+    "ui",
+    "open",
+    "uiBase",
+    "snapshotFormat",
+    "resolveSnapshotPath",
+    "passWithNoTests",
+    "onConsoleLog",
+    "onStackTrace",
+    "dangerouslyIgnoreUnhandledErrors",
+    "slowTestThreshold",
+    "inspect",
+    "inspectBrk",
+    "coverage",
+    "watchTriggerPatterns"
+  ].map(
+    (name) => findNamedProp(resolvedTestValue.properties, name)
+  ).filter(Boolean), topLevelPropSet = new Set(topLevelProps), projectTestProps = resolvedTestValue.properties.filter(
+    (p) => !topLevelPropSet.has(p)
+  ), existingTestProject = {
+    type: "ObjectExpression",
+    properties: [
+      {
+        type: "ObjectProperty",
+        key: { type: "Identifier", name: "extends" },
+        value: { type: "BooleanLiteral", value: !0 },
+        computed: !1,
+        shorthand: !1
+      },
+      {
+        type: "ObjectProperty",
+        key: { type: "Identifier", name: "test" },
+        value: {
+          type: "ObjectExpression",
+          properties: projectTestProps
+        },
+        computed: !1,
+        shorthand: !1
+      }
+    ]
+  };
+  projectsProp.value.elements.unshift(existingTestProject), targetConfigObject.properties = targetConfigObject.properties.filter(
+    (p) => p !== existingTestProp
+  ), topLevelProps.length > 0 && templateTestProp.value.type === "ObjectExpression" && templateTestProp.value.properties.unshift(...topLevelProps), mergeProperties(properties, targetConfigObject.properties);
+}, mergeTemplateIntoConfigObject = (targetConfigObject, properties, target) => {
+  let existingTestProp = findNamedProp(targetConfigObject.properties, "test"), resolvedTestValue = existingTestProp ? resolveTestPropValue(existingTestProp, target) : null, templateTestProp = findNamedProp(properties, "test");
+  if (existingTestProp && resolvedTestValue !== null) {
+    let existingProjectRefsProp = resolvedTestValue.properties.find(isProjectsArrayProp);
+    if (existingProjectRefsProp) {
+      appendToExistingProjectRefs(
+        existingProjectRefsProp,
+        resolvedTestValue,
+        templateTestProp,
+        properties,
+        targetConfigObject
+      );
+      return;
+    }
+    if (templateTestProp && templateTestProp.value.type === "ObjectExpression") {
+      wrapTestConfigAsProject(
+        resolvedTestValue,
+        existingTestProp,
+        templateTestProp,
+        properties,
+        targetConfigObject
+      );
+      return;
+    }
+  }
+  mergeProperties(properties, targetConfigObject.properties);
+}, getWritableTargetConfigObject = (target, exportDefault) => {
+  let directConfigObject = getTargetConfigObject(target, exportDefault);
+  if (directConfigObject)
+    return directConfigObject;
+  let resolvedDecl = resolveExpression(exportDefault.declaration, target);
+  if (resolvedDecl?.type !== "CallExpression" || !isDefineConfigLike(resolvedDecl, target))
+    return null;
+  let callbackArg = resolvedDecl.arguments[0];
+  if (!callbackArg || callbackArg.type !== "ArrowFunctionExpression" && callbackArg.type !== "FunctionExpression")
+    return null;
+  if (callbackArg.body.type === "ObjectExpression")
+    return callbackArg.body;
+  if (callbackArg.body.type === "BlockStatement" && callbackArg.body.body.length === 1 && callbackArg.body.body[0]?.type === "ReturnStatement") {
+    let returnedExpr = resolveExpression(callbackArg.body.body[0].argument, target);
+    if (returnedExpr?.type === "ObjectExpression")
+      return returnedExpr;
+  }
+  return null;
+}, updateConfigFile = (source, target) => {
+  let updated = !1, sourceExportDefault = source.program.body.find(
+    (n) => n.type === "ExportDefaultDeclaration"
+  );
+  if (!sourceExportDefault || sourceExportDefault.declaration.type !== "CallExpression")
+    return !1;
+  let targetExportDefault = target.program.body.find(
+    (n) => n.type === "ExportDefaultDeclaration"
+  );
+  if (!targetExportDefault)
+    return !1;
+  let canHandleConfig = !1;
+  if ((getWritableTargetConfigObject(target, targetExportDefault) !== null || getEffectiveMergeConfigCall(targetExportDefault.declaration, target) !== null) && (canHandleConfig = !0), !canHandleConfig)
+    return !1;
+  for (let sourceNode of source.program.body)
+    if (sourceNode.type === "ImportDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.specifiers.some((s) => s.local.name === sourceNode.specifiers[0].local.name)
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "VariableDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.declarations.some(
+          (d) => "name" in d.id && "name" in sourceNode.declarations[0].id && d.id.name === sourceNode.declarations[0].id.name
+        )
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "ExportDefaultDeclaration") {
+      let exportDefault = target.program.body.find((n) => n.type === "ExportDefaultDeclaration");
+      if (exportDefault && sourceNode.declaration.type === "CallExpression" && sourceNode.declaration.arguments.length > 0 && sourceNode.declaration.arguments[0].type === "ObjectExpression") {
+        let { properties } = sourceNode.declaration.arguments[0], targetConfigObject = getWritableTargetConfigObject(target, exportDefault);
+        if (targetConfigObject !== null)
+          mergeTemplateIntoConfigObject(targetConfigObject, properties, target), updated = !0;
+        else {
+          let mergeConfigCall = getEffectiveMergeConfigCall(exportDefault.declaration, target);
+          if (mergeConfigCall && mergeConfigCall.arguments.length >= 2) {
+            let configObjectNodes = [];
+            for (let arg of mergeConfigCall.arguments) {
+              let configObject = getConfigObjectFromMergeArg(arg, target);
+              configObject && configObjectNodes.push(configObject);
+            }
+            let targetConfigObject2 = configObjectNodes.find(
+              (obj) => obj.properties.some(
+                (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test"
+              )
+            ) || configObjectNodes[0];
+            if (!targetConfigObject2)
+              return !1;
+            mergeTemplateIntoConfigObject(targetConfigObject2, properties, target), updated = !0;
+          }
+        }
+      }
+    }
+  return updated;
+};
+
+// src/addon-vitest/postinstall.ts
+var ADDON_NAME = "@aussieljk/forkbook/addon-vitest", EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".cts", ".mts", ".cjs", ".mjs"], FORKBOOK_TEST_PLUGIN_SOURCE = `${ADDON_NAME}/vitest-plugin`, getTemplateConfigDir = (configFilePath, configDir) => relative(dirname(configFilePath), configDir);
+async function postInstall(options) {
+  let errors = [], { logger, prompt } = options, packageManager = JsPackageManagerFactory.getPackageManager({
+    force: options.packageManager
+  }), findFile = (basename, extensions = EXTENSIONS) => any(
+    extensions.map((ext) => basename + ext),
+    { last: getProjectRoot(), cwd: options.configDir }
+  ), allDeps = packageManager.getAllDependencies(), addonVitestService = new AddonVitestService(packageManager), info = await getStorybookInfo(options.configDir, void 0, { skipCache: !0 }), compatibilityResult = await addonVitestService.validateCompatibility({
+    framework: info.framework,
+    builder: info.builder
+  }), result = null;
+  if (!compatibilityResult.compatible && compatibilityResult.reasons) {
+    let reasons = compatibilityResult.reasons.map((r) => `\u2022 ${CLI_COLORS.error(r)}`);
+    reasons.unshift(dedent`
+      Automated setup failed
+      The following packages have incompatibilities that prevent automated setup:
+    `), reasons.push(
+      dedent`
+        You can fix these issues and rerun the command to reinstall. If you wish to roll back the installation, remove ${ADDON_NAME} from the "addons" array
+        in your main Forkbook config file and remove the dependency from your package.json file.
+
+        Please check the documentation for more information about its requirements and installation:
+        https://forkbook.ljk.dev/docs/${DOCUMENTATION_LINK}
+      `
+    ), result = reasons.map((r) => r.trim()).join(`
+
+`);
+  }
+  if (result)
+    throw logger.error(result), new AddonVitestPostinstallPrerequisiteCheckError({
+      reasons: compatibilityResult.reasons
+    });
+  if (!options.skipDependencyManagement) {
+    let versionedDependencies = await addonVitestService.collectDependencies(), v8Version = await packageManager.getInstalledVersion("@vitest/coverage-v8"), istanbulVersion = await packageManager.getInstalledVersion("@vitest/coverage-istanbul");
+    !v8Version && !istanbulVersion && logger.step(
+      dedent`
+          You don't seem to have a coverage reporter installed. Vitest needs either V8 or Istanbul to generate coverage reports.
+
+          Adding "@vitest/coverage-v8" to enable coverage reporting.
+          Read more about Vitest coverage providers at https://vitest.dev/guide/coverage.html#coverage-providers
+        `
+    ), versionedDependencies.length > 0 && (logger.step("Adding dependencies to your package.json"), logger.log("  " + versionedDependencies.join(", ")), await packageManager.addDependencies(
+      { type: "devDependencies", skipInstall: !0 },
+      versionedDependencies
+    )), options.skipInstall || await packageManager.installDependencies();
+  }
+  if (!options.skipDependencyManagement)
+    if (!options.skipInstall)
+      await addonVitestService.installPlaywright({
+        yes: options.yes,
+        useRemotePkg: !!options.skipInstall
+      });
+    else {
+      let platform = os.platform(), useWithDeps = platform === "darwin" || platform === "win32", manualCommand = useWithDeps ? "npx playwright install chromium --with-deps" : "npx playwright install chromium", linuxNote = useWithDeps ? "" : `
+        Note: add --with-deps to the command above if you are on Debian or Ubuntu.`;
+      logger.warn(dedent`
+        Playwright browser binaries installation skipped. Please run the following command manually later:
+        ${CLI_COLORS.cta(manualCommand)}${linuxNote}
+      `);
+    }
+  let fileExtension = allDeps.typescript || findFile("tsconfig", [...EXTENSIONS, ".json"]) ? "ts" : "js", viteConfigFile = findFile("vite.config"), vitestConfigFile = findFile("vitest.config"), vitestShimFile = findFile("vitest.shims.d"), rootConfig = vitestConfigFile || viteConfigFile;
+  if (fileExtension === "ts" && !vitestShimFile && await writeFile("vitest.shims.d.ts", '/// <reference types="@vitest/browser-playwright" />'), rootConfig) {
+    let target, updated, configFile = await fs.readFile(rootConfig, "utf8"), configFileHasTypeReference = configFile.match(
+      /\/\/\/\s*<reference\s+types=["']vitest\/config["']\s*\/>/
+    ), alreadyConfigured = isConfigAlreadySetup(rootConfig, configFile);
+    if (!alreadyConfigured) {
+      let configTemplate = await loadTemplate("vitest.config.4.template", {
+        CONFIG_DIR: getTemplateConfigDir(rootConfig, options.configDir)
+      }), source = babelParse(configTemplate);
+      target = babelParse(configFile), updated = updateConfigFile(source, target);
+    }
+    if (alreadyConfigured)
+      logger.step(
+        CLI_COLORS.success("Vitest for Forkbook is already properly configured. Skipping setup.")
+      );
+    else if (target && updated) {
+      logger.step(`Updating your ${vitestConfigFile ? "Vitest" : "Vite"} config file:`), logger.log(`  ${rootConfig}`);
+      let formattedContent = await formatFileContent(rootConfig, generate(target).code);
+      await writeFile(
+        rootConfig,
+        !configFileHasTypeReference && !vitestConfigFile ? `/// <reference types="vitest/config" />
+` + formattedContent : formattedContent
+      );
+    } else
+      logger.error(dedent`
+        We were unable to update your existing ${vitestConfigFile ? "Vitest" : "Vite"} config file.
+
+        Please refer to the documentation to complete the setup manually:
+        https://forkbook.ljk.dev/docs/writing-tests/integrations/vitest-addon#manual-setup-advanced
+      `), errors.push(new AddonVitestPostinstallConfigUpdateError({ filePath: rootConfig }));
+  } else {
+    let parentDir = dirname(options.configDir), newConfigFile = resolve(parentDir, `vitest.config.${fileExtension}`), configTemplate = await loadTemplate("vitest.config.4.template", {
+      CONFIG_DIR: getTemplateConfigDir(newConfigFile, options.configDir)
+    });
+    logger.step("Creating a Vitest config file:"), logger.log(`${newConfigFile}`);
+    let formattedContent = await formatFileContent(newConfigFile, configTemplate);
+    await writeFile(newConfigFile, formattedContent);
+  }
+  let runCommand = rootConfig ? "npx vitest --project=storybook" : "npx vitest";
+  if (errors.length === 0)
+    logger.step(
+      CLI_COLORS.success("@aussieljk/forkbook/addon-vitest setup completed successfully")
+    ), logger.log(dedent`
+        @aussieljk/forkbook/addon-vitest is now configured and you're ready to run your tests!
+        Here are a couple of tips to get you started:
+
+        • You can run tests with "${CLI_COLORS.cta(runCommand)}"
+        • Vitest IDE extension shows all stories as tests in your editor!
+
+        Check the documentation for more information about its features and options at:
+        https://forkbook.ljk.dev/docs/${DOCUMENTATION_LINK}
+      `);
+  else
+    throw logger.warn(
+      dedent`
+        Done, but with errors!
+        @aussieljk/forkbook/addon-vitest was installed successfully, but there were some errors during the setup process. Please refer to the documentation to complete the setup manually and check the errors above:
+        https://forkbook.ljk.dev/docs/${DOCUMENTATION_LINK}#manual-setup-advanced
+      `
+    ), new AddonVitestPostinstallError({ errors });
+}
+function isStorybookTestPluginSource(value) {
+  return value === FORKBOOK_TEST_PLUGIN_SOURCE;
+}
+function isConfigAlreadySetup(_configPath, configContent) {
+  let ast;
+  try {
+    ast = babelParse(configContent);
+  } catch {
+    return !1;
+  }
+  let pluginIdentifiers = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    ImportDeclaration(path) {
+      let source = path.node.source.value;
+      typeof source == "string" && isStorybookTestPluginSource(source) && path.node.specifiers.forEach((specifier) => {
+        "local" in specifier && specifier.local?.name && pluginIdentifiers.add(specifier.local.name);
+      });
+    }
+  });
+  let pluginReferenced = !1;
+  return traverse(ast, {
+    CallExpression(path) {
+      if (pluginReferenced) {
+        path.stop();
+        return;
+      }
+      let callee = path.node.callee;
+      callee.type === "Identifier" && (pluginIdentifiers.has(callee.name) || callee.name === "storybookTest") && (pluginReferenced = !0, path.stop());
+    }
+  }), pluginReferenced;
+}
+
+export {
+  getTemplateConfigDir,
+  postInstall,
+  isConfigAlreadySetup
+};