@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/csf-tools/index.js

@@ -0,0 +1,736 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  ConfigFile,
+  formatConfig,
+  getHeaderComments,
+  isCsfFactoryPreview,
+  loadConfig,
+  printConfig,
+  readConfig,
+  writeConfig
+} from "../_node-chunks/chunk-V2DY426G.js";
+import {
+  BadMetaError,
+  CsfFile,
+  MixedFactoryError,
+  MultipleMetaError,
+  NoMetaError,
+  authoredSource,
+  babelParseFile,
+  buildImportStatements,
+  collectImportBindings,
+  createStoryArgsResolver,
+  createStoryReferenceResolver,
+  csfFactoryReceiver,
+  enrichCsf,
+  enrichCsfMeta,
+  enrichCsfStory,
+  extractComponentDescription,
+  extractDescription,
+  extractJSDocInfo,
+  extractSource,
+  extractStoryJSDocInfo,
+  formatCsf,
+  importedName,
+  isCanonicalCsf2BindCall,
+  isCsfFactoryCall,
+  isModuleMock,
+  isSelfContained,
+  isTypeSpecifier,
+  isValidPreviewPath,
+  jsDocTagsForPath,
+  keyOf,
+  loadCsf,
+  metaObjectPath,
+  noSnippetWarning,
+  normalizeStoryDeclaration,
+  parseReferenceModule,
+  pathForNode,
+  printCsf,
+  propertyValue,
+  readCsf,
+  resolveArgValue,
+  resolveArgsRecord,
+  resolveBindingMembers,
+  resolveComponentImport,
+  resolveEffectiveRender,
+  resolveIdentifierInit,
+  resolveObjectMembers,
+  resolveReferencedValue,
+  resolveRenderFunction,
+  resolveReturnedObjectExpression,
+  returnedExpression,
+  returnedExpressionPath,
+  sourceOf,
+  templateParts,
+  unresolvedWarning,
+  unwrapExpression,
+  withoutTypeCalls,
+  writeCsf
+} from "../_node-chunks/chunk-YZFWBA5L.js";
+import "../_node-chunks/chunk-SVTBJ7Q3.js";
+import "../_node-chunks/chunk-34EO2PUT.js";
+import "../_node-chunks/chunk-TNJIXE37.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/csf-tools/index.ts
+import { babelParse as babelParse2 } from "@aussieljk/forkbook/internal/babel";
+
+// src/csf-tools/vitest-plugin/transformer.ts
+import { types as t } from "@aussieljk/forkbook/internal/babel";
+import { getStoryTitle } from "@aussieljk/forkbook/internal/common";
+import { combineTags } from "@aussieljk/forkbook/internal/csf/csf-utils";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent } from "ts-dedent";
+var isValidTest = (storyTags, tagsFilter) => !(tagsFilter.include.length && !tagsFilter.include.some((tag) => storyTags?.includes(tag)) || tagsFilter.exclude.some((tag) => storyTags?.includes(tag))), DOUBLE_SPACES = "  ", getLiteralWithZeroWidthSpace = (testTitle) => t.stringLiteral(`${testTitle}${DOUBLE_SPACES}`);
+function createTestGuardDeclaration(scope, expectId, convertToFilePathId) {
+  let isRunningFromThisFileId = scope.generateUidIdentifier("isRunningFromThisFile"), testPathProperty = t.memberExpression(
+    t.callExpression(t.memberExpression(expectId, t.identifier("getState")), []),
+    t.identifier("testPath")
+  ), filePathProperty = t.memberExpression(
+    t.memberExpression(t.identifier("globalThis"), t.identifier("__vitest_worker__")),
+    t.identifier("filepath")
+  ), nullishCoalescingExpression = t.logicalExpression(
+    "??",
+    // TODO: switch order of testPathProperty and filePathProperty when the bug is fixed
+    // https://github.com/vitest-dev/vitest/issues/6367 (or probably just use testPathProperty)
+    filePathProperty,
+    testPathProperty
+  ), includesCall = t.callExpression(
+    t.memberExpression(
+      t.callExpression(convertToFilePathId, [
+        t.memberExpression(
+          t.memberExpression(t.identifier("import"), t.identifier("meta")),
+          t.identifier("url")
+        )
+      ]),
+      t.identifier("includes")
+    ),
+    [nullishCoalescingExpression]
+  );
+  return {
+    declaration: t.variableDeclaration("const", [
+      t.variableDeclarator(isRunningFromThisFileId, includesCall)
+    ]),
+    identifier: isRunningFromThisFileId
+  };
+}
+async function vitestTransform({
+  code,
+  fileName,
+  configDir,
+  stories,
+  tagsFilter,
+  previewLevelTags = []
+}) {
+  let parsed = loadCsf(code, {
+    fileName,
+    transformInlineMeta: !0,
+    makeTitle: (title) => {
+      let result = getStoryTitle({
+        storyFilePath: fileName,
+        configDir,
+        stories,
+        userTitle: title
+      }) || "unknown";
+      return result === "unknown" && logger.warn(
+        dedent`
+            [Forkbook]: Could not calculate story title for "${fileName}".
+            Please make sure that this file matches the globs included in the "stories" field in your Forkbook configuration at "${configDir}".
+          `
+      ), result;
+    }
+  }).parse(), ast = parsed._ast, metaExportName = parsed._metaVariableName, metaNode = parsed._metaNode;
+  if (!metaNode || parsed._metaNodeIsSynthetic || !parsed._meta)
+    throw new Error(
+      `The Forkbook vitest plugin could not detect the meta (default export) object in the story file. 
+
+Please make sure you have a default export with the meta object. If you are using a different export format that is not supported, please file an issue with details about your use case.`
+    );
+  let metaTitleProperty = metaNode.properties.find(
+    (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "title"
+  ), metaTitle = t.stringLiteral(parsed._meta?.title || "unknown");
+  metaTitleProperty ? t.isObjectProperty(metaTitleProperty) && (metaTitleProperty.value = metaTitle) : metaNode.properties.push(t.objectProperty(t.identifier("title"), metaTitle));
+  let validStories = {};
+  Object.keys(parsed._stories).forEach((key) => {
+    let finalTags = combineTags(
+      "test",
+      "dev",
+      ...previewLevelTags,
+      ...parsed.meta?.tags || [],
+      ...parsed._stories[key].tags || []
+    );
+    isValidTest(finalTags, tagsFilter) && (validStories[key] = parsed._storyStatements[key]);
+  });
+  let vitestTestId = parsed._file.path.scope.generateUidIdentifier("test"), vitestDescribeId = parsed._file.path.scope.generateUidIdentifier("describe");
+  if (Object.keys(validStories).length === 0) {
+    let describeSkipBlock = t.expressionStatement(
+      t.callExpression(t.memberExpression(vitestDescribeId, t.identifier("skip")), [
+        t.stringLiteral("No valid tests found")
+      ])
+    );
+    ast.program.body.push(describeSkipBlock);
+    let imports2 = [
+      t.importDeclaration(
+        [
+          t.importSpecifier(vitestTestId, t.identifier("test")),
+          t.importSpecifier(vitestDescribeId, t.identifier("describe"))
+        ],
+        t.stringLiteral("vitest")
+      )
+    ];
+    return ast.program.body.unshift(...imports2), formatCsf(parsed, { sourceMaps: !0, sourceFileName: fileName }, code);
+  }
+  let vitestExpectId = parsed._file.path.scope.generateUidIdentifier("expect"), testStoryId = parsed._file.path.scope.generateUidIdentifier("testStory"), skipTagsId = t.identifier(JSON.stringify(tagsFilter.skip)), componentPathLiteral = parsed._rawComponentPath ? t.stringLiteral(parsed._rawComponentPath) : null, componentNameLiteral = null;
+  parsed._componentImportSpecifier && (t.isImportSpecifier(parsed._componentImportSpecifier) || t.isImportDefaultSpecifier(parsed._componentImportSpecifier)) && (componentNameLiteral = t.stringLiteral(parsed._componentImportSpecifier.local.name));
+  let { declaration: isRunningFromThisFileDeclaration, identifier: isRunningFromThisFileId } = createTestGuardDeclaration(
+    parsed._file.path.scope,
+    vitestExpectId,
+    t.identifier("convertToFilePath")
+  );
+  ast.program.body.push(isRunningFromThisFileDeclaration);
+  let getTestStatementForStory = ({
+    localName,
+    exportName,
+    testTitle,
+    node,
+    overrideSourcemap = !0,
+    storyId
+  }) => {
+    let objectProperties = [
+      t.objectProperty(t.identifier("exportName"), t.stringLiteral(exportName)),
+      t.objectProperty(t.identifier("story"), t.identifier(localName)),
+      t.objectProperty(t.identifier("meta"), t.identifier(metaExportName)),
+      t.objectProperty(t.identifier("skipTags"), skipTagsId),
+      t.objectProperty(t.identifier("storyId"), t.stringLiteral(storyId))
+    ];
+    componentPathLiteral && objectProperties.push(t.objectProperty(t.identifier("componentPath"), componentPathLiteral)), componentNameLiteral && objectProperties.push(t.objectProperty(t.identifier("componentName"), componentNameLiteral));
+    let testStoryCall = t.expressionStatement(
+      t.callExpression(vitestTestId, [
+        t.stringLiteral(testTitle),
+        t.callExpression(testStoryId, [t.objectExpression(objectProperties)])
+      ])
+    );
+    return overrideSourcemap && (testStoryCall.loc = node.loc), testStoryCall;
+  }, getDescribeStatementForStory = (options) => {
+    let { localName, describeTitle, exportName, tests, node, parentStoryId } = options, describeBlock = t.callExpression(vitestDescribeId, [
+      getLiteralWithZeroWidthSpace(describeTitle),
+      t.arrowFunctionExpression(
+        [],
+        t.blockStatement([
+          getTestStatementForStory({
+            ...options,
+            testTitle: "base story",
+            overrideSourcemap: !1,
+            storyId: parentStoryId
+          }),
+          ...tests.map(({ name: testName, node: testNode, id: storyId }) => {
+            let objectProperties = [
+              t.objectProperty(t.identifier("exportName"), t.stringLiteral(exportName)),
+              t.objectProperty(t.identifier("story"), t.identifier(localName)),
+              t.objectProperty(t.identifier("meta"), t.identifier(metaExportName)),
+              t.objectProperty(t.identifier("skipTags"), skipTagsId),
+              t.objectProperty(t.identifier("storyId"), t.stringLiteral(storyId))
+            ];
+            componentPathLiteral && objectProperties.push(
+              t.objectProperty(t.identifier("componentPath"), componentPathLiteral)
+            ), componentNameLiteral && objectProperties.push(
+              t.objectProperty(t.identifier("componentName"), componentNameLiteral)
+            ), testName && objectProperties.push(
+              t.objectProperty(t.identifier("testName"), t.stringLiteral(testName))
+            );
+            let testStatement = t.expressionStatement(
+              t.callExpression(vitestTestId, [
+                t.stringLiteral(testName),
+                t.callExpression(testStoryId, [t.objectExpression(objectProperties)])
+              ])
+            );
+            return testStatement.loc = testNode.loc, testStatement;
+          })
+        ])
+      )
+    ]);
+    return describeBlock.loc = node.loc, t.expressionStatement(describeBlock);
+  }, storyTestStatements = Object.entries(validStories).map(([exportName, node]) => {
+    if (node === null) {
+      logger.warn(
+        dedent`
+            [Forkbook]: Could not transform "${exportName}" story into test at "${fileName}".
+            Please make sure to define stories in the same file and not re-export stories coming from other files".
+          `
+      );
+      return;
+    }
+    let localName = parsed._stories[exportName].localName ?? exportName, testTitle = parsed._stories[exportName].name ?? exportName, storyId = parsed._stories[exportName].id, tests = parsed.getStoryTests(exportName);
+    return tests?.length > 0 ? getDescribeStatementForStory({
+      localName,
+      describeTitle: testTitle,
+      exportName,
+      tests,
+      node,
+      parentStoryId: storyId
+    }) : getTestStatementForStory({
+      testTitle,
+      localName,
+      exportName,
+      node,
+      storyId
+    });
+  }).filter((st) => !!st), testBlock = t.ifStatement(isRunningFromThisFileId, t.blockStatement(storyTestStatements));
+  ast.program.body.push(testBlock);
+  let hasTests = Object.keys(validStories).some(
+    (exportName) => parsed.getStoryTests(exportName).length > 0
+  ), imports = [
+    t.importDeclaration(
+      [
+        t.importSpecifier(vitestTestId, t.identifier("test")),
+        t.importSpecifier(vitestExpectId, t.identifier("expect")),
+        ...hasTests ? [t.importSpecifier(vitestDescribeId, t.identifier("describe"))] : []
+      ],
+      t.stringLiteral("vitest")
+    ),
+    t.importDeclaration(
+      [
+        t.importSpecifier(testStoryId, t.identifier("testStory")),
+        t.importSpecifier(t.identifier("convertToFilePath"), t.identifier("convertToFilePath"))
+      ],
+      t.stringLiteral("@aussieljk/forkbook/addon-vitest/internal/test-utils")
+    )
+  ];
+  return ast.program.body.unshift(...imports), formatCsf(parsed, { sourceMaps: !0, sourceFileName: fileName }, code);
+}
+
+// src/csf-tools/vitest-plugin/component-transformer.ts
+import path from "node:path";
+import {
+  BabelFileClass,
+  babelParse,
+  generate,
+  types as t2,
+  traverse
+} from "@aussieljk/forkbook/internal/babel";
+
+// src/core-server/utils/get-dummy-args-from-argtypes.ts
+var FORKBOOK_FN_PLACEHOLDER = "[[FORKBOOK_FN_PLACEHOLDER]]";
+function generateDummyArgsFromArgTypes(argTypes, options = {}) {
+  let required = {}, optional = {};
+  for (let [propName, argType] of Object.entries(argTypes)) {
+    let isRequired = argType.type && typeof argType.type == "object" && argType.type.required, dummyValue;
+    if (typeof argType.type == "string") {
+      let sbType = { name: argType.type };
+      dummyValue = generateDummyValueFromSBType(sbType, propName, options);
+    } else argType.type && typeof argType.type == "object" ? dummyValue = generateDummyValueFromSBType(argType.type, propName, options) : dummyValue = void 0;
+    isRequired ? required[propName] = dummyValue : optional[propName] = dummyValue;
+  }
+  return { required, optional };
+}
+function tokenize(name) {
+  return name ? name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").split(" ").map((t3) => t3.toLowerCase()).filter(Boolean) : [];
+}
+function hasAny(tokens, set) {
+  return tokens.some((t3) => set.has(t3));
+}
+var URL_TOKENS = /* @__PURE__ */ new Set(["url", "href", "link"]), IMAGE_TOKENS = /* @__PURE__ */ new Set(["image", "img", "photo", "avatar", "logo"]), EMAIL_TOKENS = /* @__PURE__ */ new Set(["email", "e-mail", "mail"]), PHONE_TOKENS = /* @__PURE__ */ new Set(["phone", "tel", "telephone", "mobile", "cell"]), COLOR_TOKENS = /* @__PURE__ */ new Set(["color", "background", "bg"]), DATE_TOKENS = /* @__PURE__ */ new Set(["date", "at", "time", "timestamp"]), NEGATIVE_IMAGE_TOKENS = /* @__PURE__ */ new Set([
+  "size",
+  "width",
+  "height",
+  "ratio",
+  "count",
+  "status",
+  "loading",
+  "config",
+  "options",
+  "variant"
+]);
+function getMostLikelyTypeFromTokens(tokens) {
+  let score = {};
+  for (let token of tokens)
+    IMAGE_TOKENS.has(token) && (score.image = (score.image ?? 0) + 3), URL_TOKENS.has(token) && (score.url = (score.url ?? 0) + 2), EMAIL_TOKENS.has(token) && (score.email = (score.email ?? 0) + 3), PHONE_TOKENS.has(token) && (score.phone = (score.phone ?? 0) + 3);
+  hasAny(tokens, NEGATIVE_IMAGE_TOKENS) && (score.image = (score.image ?? 0) - 4);
+  let best = null, bestScore = 0;
+  for (let [kind, value] of Object.entries(score))
+    value > bestScore && (bestScore = value, best = kind);
+  return best;
+}
+function normalizeStringLiteral(value) {
+  return typeof value != "string" ? value : value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1) : value;
+}
+function generateDummyValueFromSBType(sbType, propName, options) {
+  switch (sbType.name) {
+    case "boolean":
+      return !0;
+    case "number":
+      return 0;
+    case "string": {
+      let name = propName ?? "", tokens = tokenize(name);
+      if (hasAny(tokens, COLOR_TOKENS))
+        return "#ff4785";
+      if (hasAny(tokens, DATE_TOKENS))
+        return (/* @__PURE__ */ new Date()).toLocaleDateString();
+      let mostLikelyType = getMostLikelyTypeFromTokens(tokens);
+      if (options?.skipUrlGeneration && (mostLikelyType === "image" || mostLikelyType === "url"))
+        return name;
+      switch (mostLikelyType) {
+        case "image":
+          return "https://placehold.co/600x400?text=Forkbook";
+        case "url":
+          return "https://example.com";
+        case "email":
+          return "storybook@example.com";
+        case "phone":
+          return "1234567890";
+        default:
+          return name ?? "Hello world";
+      }
+    }
+    case "date":
+      return /* @__PURE__ */ new Date();
+    case "node":
+      return propName ?? "Hello world";
+    case "function":
+      return FORKBOOK_FN_PLACEHOLDER;
+    case "literal":
+      return normalizeStringLiteral(sbType.value);
+    case "object": {
+      let result = {};
+      for (let [key, valueType] of Object.entries(sbType.value))
+        result[key] = generateDummyValueFromSBType(valueType, key, options);
+      return result;
+    }
+    case "union": {
+      if (!sbType.value?.length)
+        return "";
+      let literalType = sbType.value.find((t3) => t3.name === "literal");
+      return literalType?.name === "literal" ? normalizeStringLiteral(literalType.value) : generateDummyValueFromSBType(sbType.value[0], propName, options);
+    }
+    case "array": {
+      let v = sbType.value;
+      return v?.length < 1 || v[0]?.name === "other" ? [] : [generateDummyValueFromSBType(v[0], propName, options)];
+    }
+    case "tuple":
+      return sbType.value.map((el) => generateDummyValueFromSBType(el, void 0, options));
+    case "enum":
+      return sbType.value[0] ?? propName;
+    case "intersection": {
+      let objectTypes = sbType.value.filter((t3) => t3.name === "object");
+      if (objectTypes.length > 0) {
+        let result = {};
+        return objectTypes.forEach((objType) => {
+          objType.name === "object" && Object.entries(objType.value).forEach(([key, type]) => {
+            result[key] = generateDummyValueFromSBType(type, key, options);
+          });
+        }), result;
+      }
+      return {};
+    }
+    case "other": {
+      let value = sbType.value;
+      return value?.startsWith("React") || value?.includes("Event") || value?.includes("Element") ? FORKBOOK_FN_PLACEHOLDER : value === "null" ? null : value === "void" || value === "undefined" ? void 0 : null;
+    }
+  }
+}
+
+// src/csf-tools/vitest-plugin/component-transformer.ts
+var VITEST_IMPORT_SOURCE = "vitest", TEST_UTILS_IMPORT_SOURCE = "@aussieljk/forkbook/addon-vitest/internal/test-utils", FORKBOOK_TEST_IMPORT_SOURCE = "@aussieljk/forkbook/test", sanitizeIdentifier = (value) => value.replace(/[^a-zA-Z0-9_$]+/g, "") || "Component", createComponentNameFromFileName = (fileName) => {
+  if (!fileName)
+    return "Component";
+  let basename = path.basename(fileName, path.extname(fileName));
+  return sanitizeIdentifier(basename);
+}, containsJsxNode = (valuePath) => {
+  if (!valuePath?.node)
+    return !1;
+  let found = !1;
+  return valuePath.traverse({
+    JSXElement(path2) {
+      found = !0, path2.stop();
+    },
+    JSXFragment(path2) {
+      found = !0, path2.stop();
+    }
+  }), found;
+}, unwrapExpression2 = (node) => node ? t2.isTSAsExpression(node) || t2.isTSSatisfiesExpression(node) ? unwrapExpression2(node.expression) : node : null, dedupeImports = (program, source, specifiers) => {
+  let existing = program.body.find(
+    (node) => t2.isImportDeclaration(node) && node.source.value === source
+  );
+  if (existing) {
+    specifiers.forEach((specifier) => {
+      existing.specifiers.every(
+        (existingSpecifier) => !t2.isImportSpecifier(existingSpecifier) || existingSpecifier.local.name !== specifier.local.name
+      ) && existing.specifiers.push(specifier);
+    });
+    return;
+  }
+  program.body.unshift(t2.importDeclaration(specifiers, t2.stringLiteral(source)));
+}, collectComponentExports = (program, fileName) => {
+  let components = [], addComponent = (exportedName, localIdentifier, valuePath) => {
+    !valuePath || !valuePath.node || !unwrapExpression2(valuePath.node) || containsJsxNode(valuePath) && components.push({ exportedName, localIdentifier });
+  };
+  return traverse(program, {
+    ExportNamedDeclaration(path2) {
+      let { node } = path2;
+      if (node.source)
+        return;
+      let declarationPath = path2.get("declaration");
+      if (declarationPath.isVariableDeclaration())
+        declarationPath.get("declarations").forEach((declPath) => {
+          if (!declPath.isVariableDeclarator())
+            return;
+          let id = declPath.node.id;
+          if (!t2.isIdentifier(id))
+            return;
+          let initPath = declPath.get("init");
+          addComponent(id.name, id, initPath);
+        });
+      else if (declarationPath.isFunctionDeclaration() && declarationPath.node.id) {
+        let declarationId = declarationPath.node.id;
+        t2.isIdentifier(declarationId) && addComponent(declarationId.name, declarationId, declarationPath);
+      } else if (declarationPath.isClassDeclaration() && declarationPath.node.id) {
+        let declarationId = declarationPath.node.id;
+        t2.isIdentifier(declarationId) && addComponent(declarationId.name, declarationId, declarationPath);
+      }
+      path2.get("specifiers").forEach((specifierPath) => {
+        if (!specifierPath.isExportSpecifier())
+          return;
+        let { local, exported } = specifierPath.node;
+        if (!t2.isIdentifier(local) || !t2.isIdentifier(exported))
+          return;
+        let binding = specifierPath.scope.getBinding(local.name);
+        if (!binding)
+          return;
+        let bindingPath = binding.path, localIdentifier = binding.identifier;
+        if (t2.isIdentifier(localIdentifier)) {
+          if (bindingPath.isVariableDeclarator())
+            addComponent(exported.name, localIdentifier, bindingPath.get("init"));
+          else if (bindingPath.isFunctionDeclaration() || bindingPath.isClassDeclaration()) {
+            let bindingNodeId = bindingPath.node.id;
+            t2.isIdentifier(bindingNodeId) && addComponent(exported.name, localIdentifier, bindingPath);
+          }
+        }
+      });
+    },
+    ExportDefaultDeclaration(path2) {
+      let { node } = path2, declaration = node.declaration;
+      if (t2.isFunctionExpression(declaration) || t2.isArrowFunctionExpression(declaration) || t2.isClassExpression(declaration)) {
+        let identifierName = createComponentNameFromFileName(fileName), identifier = path2.scope.generateUidIdentifier(identifierName), variableDeclaration = t2.variableDeclaration("const", [
+          t2.variableDeclarator(identifier, declaration)
+        ]);
+        variableDeclaration.loc = node.loc, path2.insertBefore(variableDeclaration), node.declaration = identifier;
+        let insertedVarPath = path2.getPrevSibling(), initPath = null;
+        if (insertedVarPath?.isVariableDeclaration()) {
+          let declarationPath = insertedVarPath.get("declarations")[0];
+          declarationPath?.isVariableDeclarator() && (initPath = declarationPath.get("init"));
+        }
+        addComponent(identifierName, identifier, initPath);
+        return;
+      }
+      if (t2.isCallExpression(declaration)) {
+        let identifierName = createComponentNameFromFileName(fileName), identifier = path2.scope.generateUidIdentifier(identifierName), variableDeclaration = t2.variableDeclaration("const", [
+          t2.variableDeclarator(identifier, declaration)
+        ]);
+        variableDeclaration.loc = node.loc, path2.insertBefore(variableDeclaration), node.declaration = identifier, components.push({ exportedName: identifierName, localIdentifier: identifier });
+        return;
+      }
+      if (t2.isIdentifier(declaration)) {
+        let binding = path2.scope.getBinding(declaration.name);
+        if (!binding)
+          return;
+        let bindingIdentifier = binding.identifier;
+        if (!t2.isIdentifier(bindingIdentifier))
+          return;
+        if (binding.path.isVariableDeclarator())
+          addComponent(
+            createComponentNameFromFileName(fileName),
+            bindingIdentifier,
+            binding.path.get("init")
+          );
+        else if (binding.path.isFunctionDeclaration() || binding.path.isClassDeclaration()) {
+          let bindingNodeId = binding.path.node.id;
+          t2.isIdentifier(bindingNodeId) && addComponent(bindingNodeId.name, bindingIdentifier, binding.path);
+        }
+        return;
+      }
+      if (t2.isFunctionDeclaration(declaration) && declaration.id) {
+        addComponent(
+          declaration.id.name,
+          declaration.id,
+          path2.get("declaration")
+        );
+        return;
+      }
+      t2.isClassDeclaration(declaration) && declaration.id && addComponent(
+        declaration.id.name,
+        declaration.id,
+        path2.get("declaration")
+      );
+    }
+  }), components;
+}, componentTransform = async ({
+  code,
+  fileName,
+  getComponentArgTypes
+}) => {
+  let ast = babelParse(code), file = new BabelFileClass({ filename: fileName, highlightCode: !1 }, { code, ast }), components = collectComponentExports(ast.program, fileName);
+  if (!components.length)
+    return { code, map: null };
+  let vitestTestId = file.path.scope.generateUidIdentifier("test"), vitestExpectId = file.path.scope.generateUidIdentifier("expect"), testStoryId = file.path.scope.generateUidIdentifier("testStory"), convertToFilePathId = t2.identifier("convertToFilePath"), fnId = file.path.scope.generateUidIdentifier("fn");
+  dedupeImports(ast.program, VITEST_IMPORT_SOURCE, [
+    t2.importSpecifier(vitestTestId, t2.identifier("test")),
+    t2.importSpecifier(vitestExpectId, t2.identifier("expect"))
+  ]), dedupeImports(ast.program, TEST_UTILS_IMPORT_SOURCE, [
+    t2.importSpecifier(testStoryId, t2.identifier("testStory")),
+    t2.importSpecifier(convertToFilePathId, t2.identifier("convertToFilePath"))
+  ]);
+  let testStatements = [], hasFunctionPlaceholder = (value) => JSON.stringify(value).includes(FORKBOOK_FN_PLACEHOLDER), valueToNodeRecursive = (value, replaceFnCalls) => {
+    if (!replaceFnCalls)
+      return t2.valueToNode(value);
+    if (value === FORKBOOK_FN_PLACEHOLDER)
+      return t2.callExpression(fnId, []);
+    if (typeof value == "object" && value !== null) {
+      if (Array.isArray(value))
+        return t2.arrayExpression(value.map((val) => valueToNodeRecursive(val, replaceFnCalls)));
+      let properties = Object.entries(value).map(([key, val]) => {
+        let keyNode = t2.isValidIdentifier(key) ? t2.identifier(key) : t2.stringLiteral(key);
+        return t2.objectProperty(keyNode, valueToNodeRecursive(val, replaceFnCalls));
+      });
+      return t2.objectExpression(properties);
+    }
+    return t2.valueToNode(value);
+  }, buildArgsExpression = (args, useFnImport = !1) => {
+    if (!args || Object.keys(args).length === 0)
+      return t2.objectExpression([]);
+    let properties = Object.entries(args).map(([key, value]) => {
+      let keyNode = t2.isValidIdentifier(key) ? t2.identifier(key) : t2.stringLiteral(key);
+      return t2.objectProperty(keyNode, valueToNodeRecursive(value, useFnImport));
+    });
+    return t2.objectExpression(properties);
+  }, hasAnyFunctionPlaceholders = !1;
+  for (let component of components) {
+    let argTypes = getComponentArgTypes ? await getComponentArgTypes({ componentName: component.exportedName, fileName }) : void 0, generatedArgs = argTypes ? generateDummyArgsFromArgTypes(argTypes, { skipUrlGeneration: !0 }).required : void 0;
+    !hasAnyFunctionPlaceholders && generatedArgs && hasFunctionPlaceholder(generatedArgs) && (hasAnyFunctionPlaceholders = !0);
+    let meta = t2.objectExpression([
+      t2.objectProperty(
+        t2.identifier("title"),
+        t2.stringLiteral(`generated/tests/${component.exportedName}`)
+      ),
+      t2.objectProperty(t2.identifier("component"), component.localIdentifier)
+    ]), testStoryArgs = t2.objectExpression([
+      t2.objectProperty(t2.identifier("exportName"), t2.stringLiteral(component.exportedName)),
+      // This is where the story annotation for a particular component is defined, inline
+      t2.objectProperty(
+        t2.identifier("story"),
+        t2.objectExpression([
+          t2.objectProperty(
+            t2.identifier("args"),
+            buildArgsExpression(generatedArgs, hasAnyFunctionPlaceholders)
+          )
+        ])
+      ),
+      t2.objectProperty(t2.identifier("meta"), meta),
+      t2.objectProperty(t2.identifier("skipTags"), t2.arrayExpression([])),
+      t2.objectProperty(
+        t2.identifier("storyId"),
+        t2.stringLiteral(`generated-${component.exportedName}`)
+      ),
+      t2.objectProperty(t2.identifier("componentPath"), t2.stringLiteral(fileName)),
+      t2.objectProperty(
+        t2.identifier("componentName"),
+        t2.stringLiteral(component.localIdentifier.name)
+      )
+    ]), testCall = t2.expressionStatement(
+      t2.callExpression(vitestTestId, [
+        t2.stringLiteral(component.exportedName),
+        t2.callExpression(testStoryId, [testStoryArgs])
+      ])
+    );
+    testStatements.push(testCall);
+  }
+  hasAnyFunctionPlaceholders && dedupeImports(ast.program, FORKBOOK_TEST_IMPORT_SOURCE, [
+    t2.importSpecifier(fnId, t2.identifier("fn"))
+  ]);
+  let { declaration: guardDeclaration, identifier: guardIdentifier } = createTestGuardDeclaration(
+    file.path.scope,
+    vitestExpectId,
+    convertToFilePathId
+  );
+  return ast.program.body.push(guardDeclaration), ast.program.body.push(t2.ifStatement(guardIdentifier, t2.blockStatement(testStatements))), generate(ast, { sourceMaps: !0, sourceFileName: fileName }, code);
+};
+export {
+  BadMetaError,
+  ConfigFile,
+  CsfFile,
+  MixedFactoryError,
+  MultipleMetaError,
+  NoMetaError,
+  authoredSource,
+  babelParse2 as babelParse,
+  babelParseFile,
+  buildImportStatements,
+  collectImportBindings,
+  componentTransform,
+  createStoryArgsResolver,
+  createStoryReferenceResolver,
+  csfFactoryReceiver,
+  enrichCsf,
+  enrichCsfMeta,
+  enrichCsfStory,
+  extractComponentDescription,
+  extractDescription,
+  extractJSDocInfo,
+  extractSource,
+  extractStoryJSDocInfo,
+  formatConfig,
+  formatCsf,
+  getHeaderComments,
+  importedName,
+  isCanonicalCsf2BindCall,
+  isCsfFactoryCall,
+  isCsfFactoryPreview,
+  isModuleMock,
+  isSelfContained,
+  isTypeSpecifier,
+  isValidPreviewPath,
+  jsDocTagsForPath,
+  keyOf,
+  loadConfig,
+  loadCsf,
+  metaObjectPath,
+  noSnippetWarning,
+  normalizeStoryDeclaration,
+  parseReferenceModule,
+  pathForNode,
+  printConfig,
+  printCsf,
+  propertyValue,
+  readConfig,
+  readCsf,
+  resolveArgValue,
+  resolveArgsRecord,
+  resolveBindingMembers,
+  resolveComponentImport,
+  resolveEffectiveRender,
+  resolveIdentifierInit,
+  resolveObjectMembers,
+  resolveReferencedValue,
+  resolveRenderFunction,
+  resolveReturnedObjectExpression,
+  returnedExpression,
+  returnedExpressionPath,
+  sourceOf,
+  templateParts,
+  unresolvedWarning,
+  unwrapExpression,
+  vitestTransform,
+  withoutTypeCalls,
+  writeConfig,
+  writeCsf
+};