@storybook/angular-vite 0.0.0-canary-test

package/dist/_browser-chunks/chunk-CIJX6X7B.js

@@ -0,0 +1,246 @@
+import {
+  __export,
+  computesTemplateFromComponent,
+  render,
+  renderToCanvas
+} from "./chunk-6U6AH4EH.js";
+
+// src/client/config.ts
+var config_exports = {};
+__export(config_exports, {
+  applyDecorators: () => decorateStory,
+  argTypesEnhancers: () => argTypesEnhancers,
+  parameters: () => parameters,
+  render: () => render,
+  renderToCanvas: () => renderToCanvas
+});
+
+// src/client/globals.ts
+import { global } from "@storybook/global";
+global.STORYBOOK_ENV = "angular";
+
+// src/client/decorateStory.ts
+import { sanitizeStoryContextUpdate } from "storybook/preview-api";
+function decorateStory(mainStoryFn, decorators) {
+  return [cleanArgsDecorator, ...decorators].reduce(
+    (previousStoryFn, decorator) => (context) => decorator((update) => previousStoryFn({
+      ...context,
+      ...sanitizeStoryContextUpdate(update)
+    }), context),
+    (context) => prepareMain(mainStoryFn(context), context)
+  );
+}
+var prepareMain = (story, context) => {
+  let { template } = story, { component } = context, userDefinedTemplate = !hasNoTemplate(template);
+  return !userDefinedTemplate && component && (template = computesTemplateFromComponent(component, story.props, "")), {
+    ...story,
+    ...template ? { template, userDefinedTemplate } : {}
+  };
+};
+function hasNoTemplate(template) {
+  return template == null;
+}
+var cleanArgsDecorator = (storyFn, context) => {
+  if (!context.argTypes || !context.args || Object.keys(context.argTypes).length === 0)
+    return storyFn();
+  let argsToClean = context.args;
+  return context.args = Object.entries(argsToClean).reduce((obj, [key, arg]) => {
+    let argType = context.argTypes[key];
+    return argType?.action || argType?.control ? { ...obj, [key]: arg } : obj;
+  }, {}), storyFn();
+};
+
+// src/client/config.ts
+import { enhanceArgTypes } from "storybook/internal/docs-tools";
+
+// src/client/compodoc.ts
+import { logger } from "storybook/internal/client-logger";
+import { global as global2 } from "@storybook/global";
+var { FEATURES } = global2, isMethod = (methodOrProp) => methodOrProp.args !== void 0;
+var getCompodocJson = () => global2.__STORYBOOK_COMPODOC_JSON__, checkValidComponentOrDirective = (component) => {
+  if (!component.name)
+    throw new Error(`Invalid component ${JSON.stringify(component)}`);
+}, checkValidCompodocJson = (compodocJson) => {
+  if (!compodocJson || !compodocJson.components)
+    throw new Error("Invalid compodoc JSON");
+}, hasDecorator = (item, decoratorName) => item.decorators && item.decorators.find((x) => x.name === decoratorName), mapPropertyToSection = (item) => hasDecorator(item, "ViewChild") ? "view child" : hasDecorator(item, "ViewChildren") ? "view children" : hasDecorator(item, "ContentChild") ? "content child" : hasDecorator(item, "ContentChildren") ? "content children" : "properties", mapItemToSection = (key, item) => {
+  switch (key) {
+    case "methods":
+    case "methodsClass":
+      return "methods";
+    case "inputsClass":
+      return "inputs";
+    case "outputsClass":
+      return "outputs";
+    case "properties":
+    case "propertiesClass":
+      if (isMethod(item))
+        throw new Error("Cannot be of type Method if key === 'propertiesClass'");
+      return mapPropertyToSection(item);
+    default:
+      throw new Error(`Unknown key: ${key}`);
+  }
+}, findComponentByName = (name, compodocJson) => compodocJson.components.find((c) => c.name === name) || compodocJson.directives.find((c) => c.name === name) || compodocJson.pipes.find((c) => c.name === name) || compodocJson.injectables.find((c) => c.name === name) || compodocJson.classes.find((c) => c.name === name), getComponentData = (component) => {
+  if (!component)
+    return null;
+  checkValidComponentOrDirective(component);
+  let compodocJson = getCompodocJson();
+  if (!compodocJson)
+    return null;
+  checkValidCompodocJson(compodocJson);
+  let { name } = component, metadata = findComponentByName(name, compodocJson);
+  return metadata || logger.warn(`Component not found in compodoc JSON: '${name}'`), metadata;
+}, displaySignature = (item) => `(${item.args.map(
+  (arg) => `${arg.name}${arg.optional ? "?" : ""}: ${arg.type}`
+).join(", ")}) => ${item.returnType}`, extractTypeFromValue = (defaultValue) => {
+  let valueType = typeof defaultValue;
+  return defaultValue || valueType === "number" || valueType === "boolean" || valueType === "string" ? valueType : null;
+}, extractEnumValues = (compodocType) => {
+  let enumType = getCompodocJson()?.miscellaneous?.enumerations?.find((x) => x.name === compodocType);
+  if (enumType?.childs.every((x) => x.value))
+    return enumType.childs.map((x) => x.value);
+  if (typeof compodocType != "string" || compodocType.indexOf("|") === -1)
+    return null;
+  try {
+    return compodocType.split("|").map((value) => JSON.parse(value));
+  } catch {
+    return null;
+  }
+}, extractType = (property, defaultValue) => {
+  let compodocType = property.type || extractTypeFromValue(defaultValue);
+  switch (compodocType) {
+    case "string":
+    case "boolean":
+    case "number":
+      return { name: compodocType };
+    case void 0:
+    case null:
+      return { name: "other", value: "void" };
+    default: {
+      let resolvedType = resolveTypealias(compodocType), enumValues = extractEnumValues(resolvedType);
+      return enumValues ? { name: "enum", value: enumValues } : { name: "other", value: "empty-enum" };
+    }
+  }
+}, castDefaultValue = (property, defaultValue) => {
+  let compodocType = property.type;
+  if (["boolean", "number", "string", "EventEmitter"].includes(compodocType))
+    switch (compodocType) {
+      case "boolean":
+        return defaultValue === "true";
+      case "number":
+        return Number(defaultValue);
+      case "EventEmitter":
+        return;
+      default:
+        return defaultValue;
+    }
+  else
+    switch (defaultValue) {
+      case "true":
+        return !0;
+      case "false":
+        return !1;
+      case "null":
+        return null;
+      case "undefined":
+        return;
+      default:
+        return defaultValue;
+    }
+}, extractDefaultValueFromComments = (property, value) => {
+  let commentValue = value;
+  return property.jsdoctags.forEach((tag) => {
+    ["default", "defaultvalue"].includes(tag.tagName.escapedText) && (commentValue = new global2.DOMParser().parseFromString(tag.comment, "text/html").body.textContent);
+  }), commentValue;
+}, extractDefaultValue = (property) => {
+  try {
+    let value = property.defaultValue?.replace(/^'(.*)'$/, "$1");
+    return value = castDefaultValue(property, value), value == null && property.jsdoctags?.length > 0 && (value = extractDefaultValueFromComments(property, value)), value;
+  } catch {
+    logger.debug(`Error extracting ${property.name}: ${property.defaultValue}`);
+    return;
+  }
+}, resolveTypealias = (compodocType) => {
+  let typeAlias = getCompodocJson()?.miscellaneous?.typealiases?.find((x) => x.name === compodocType);
+  return typeAlias ? resolveTypealias(typeAlias.rawtype) : compodocType;
+}, extractArgTypesFromData = (componentData) => {
+  let sectionToItems = {}, componentClasses = FEATURES.angularFilterNonInputControls ? ["inputsClass"] : ["propertiesClass", "methodsClass", "inputsClass", "outputsClass"], compodocClasses = ["component", "directive"].includes(componentData.type) ? componentClasses : ["properties", "methods"], inputClassNames = new Set(
+    (componentData.inputsClass || []).map((item) => item.name)
+  ), modelProperties = (componentData.outputsClass || []).filter((item) => inputClassNames.has(item.name)), modelPropertyNames = new Set(modelProperties.map((item) => item.name));
+  compodocClasses.forEach((key) => {
+    (componentData[key] || []).forEach((item) => {
+      let section = mapItemToSection(key, item);
+      if (key === "outputsClass" && !isMethod(item) && modelPropertyNames.has(item.name))
+        return;
+      let defaultValue = isMethod(item) ? void 0 : extractDefaultValue(item), type = isMethod(item) || section !== "inputs" && section !== "properties" ? { name: "other", value: "void" } : extractType(item, defaultValue), action = section === "outputs" ? { action: item.name } : {}, argType = {
+        name: item.name,
+        description: item.rawdescription || item.description,
+        type,
+        ...action,
+        table: {
+          category: section,
+          type: {
+            summary: isMethod(item) ? displaySignature(item) : item.type,
+            required: isMethod(item) ? !1 : !item.optional
+          },
+          defaultValue: { summary: defaultValue }
+        }
+      };
+      sectionToItems[section] || (sectionToItems[section] = []), sectionToItems[section].push(argType);
+    });
+  }), modelProperties.forEach((item) => {
+    let changeName = `${item.name}Change`, argType = {
+      name: changeName,
+      description: item.rawdescription || item.description,
+      type: { name: "other", value: "void" },
+      action: changeName,
+      table: {
+        category: "outputs",
+        type: {
+          summary: `(e: ${item.type}) => void`,
+          required: !item.optional
+        }
+      }
+    };
+    sectionToItems.outputs || (sectionToItems.outputs = []), sectionToItems.outputs.push(argType);
+  });
+  let SECTIONS = [
+    "properties",
+    "inputs",
+    "outputs",
+    "methods",
+    "view child",
+    "view children",
+    "content child",
+    "content children"
+  ], argTypes = {};
+  return SECTIONS.forEach((section) => {
+    let items = sectionToItems[section];
+    items && items.forEach((argType) => {
+      argTypes[argType.name] = argType;
+    });
+  }), argTypes;
+}, extractArgTypes = (component) => {
+  let componentData = getComponentData(component);
+  return componentData && extractArgTypesFromData(componentData);
+}, extractComponentDescription = (component) => {
+  let componentData = getComponentData(component);
+  return componentData && (componentData.rawdescription || componentData.description);
+};
+
+// src/client/config.ts
+var parameters = {
+  renderer: "angular",
+  docs: {
+    story: { inline: !0 },
+    extractArgTypes,
+    extractComponentDescription
+  }
+}, argTypesEnhancers = [enhanceArgTypes];
+
+export {
+  decorateStory,
+  parameters,
+  argTypesEnhancers,
+  config_exports
+};

package/dist/_browser-chunks/chunk-TARB3NLN.js

@@ -0,0 +1,93 @@
+import {
+  config_exports
+} from "./chunk-CIJX6X7B.js";
+import {
+  config_exports as config_exports2
+} from "./chunk-4WZEHS2U.js";
+import {
+  computesTemplateFromComponent,
+  formatPropInTemplate,
+  isComponent,
+  render_exports
+} from "./chunk-6U6AH4EH.js";
+
+// src/client/portable-stories.ts
+import {
+  setProjectAnnotations as originalSetProjectAnnotations,
+  setDefaultProjectAnnotations
+} from "storybook/preview-api";
+function setProjectAnnotations(projectAnnotations) {
+  return setDefaultProjectAnnotations(render_exports), originalSetProjectAnnotations(
+    projectAnnotations
+  );
+}
+
+// src/client/preview.ts
+import { definePreview as definePreviewBase } from "storybook/internal/csf";
+function __definePreview(input) {
+  return definePreviewBase({
+    ...input,
+    addons: [config_exports, config_exports2, ...input.addons ?? []]
+  });
+}
+
+// src/client/decorators.ts
+var moduleMetadata = (metadata) => (storyFn) => {
+  let story = storyFn(), storyMetadata = story.moduleMetadata || {};
+  return metadata = metadata || {}, {
+    ...story,
+    moduleMetadata: {
+      declarations: [...metadata.declarations || [], ...storyMetadata.declarations || []],
+      entryComponents: [
+        ...metadata.entryComponents || [],
+        ...storyMetadata.entryComponents || []
+      ],
+      imports: [...metadata.imports || [], ...storyMetadata.imports || []],
+      schemas: [...metadata.schemas || [], ...storyMetadata.schemas || []],
+      providers: [...metadata.providers || [], ...storyMetadata.providers || []]
+    }
+  };
+};
+function applicationConfig(config) {
+  return (storyFn) => {
+    let story = storyFn(), storyConfig = story.applicationConfig;
+    return {
+      ...story,
+      applicationConfig: storyConfig || config ? {
+        ...config,
+        ...storyConfig,
+        providers: [...config?.providers || [], ...storyConfig?.providers || []]
+      } : void 0
+    };
+  };
+}
+var componentWrapperDecorator = (element, props) => (storyFn, storyContext) => {
+  let story = storyFn(), currentProps = typeof props == "function" ? props(storyContext) : props, template = isComponent(element) ? computesTemplateFromComponent(element, currentProps ?? {}, story.template) : element(story.template);
+  return {
+    ...story,
+    template,
+    ...currentProps || story.props ? {
+      props: {
+        ...currentProps,
+        ...story.props
+      }
+    } : {}
+  };
+};
+
+// src/client/argsToTemplate.ts
+function argsToTemplate(args, options = {}) {
+  let includeSet = options.include ? new Set(options.include) : null, excludeSet = options.exclude ? new Set(options.exclude) : null;
+  return Object.entries(args).filter(([key]) => args[key] !== void 0).filter(([key]) => includeSet ? includeSet.has(key) : excludeSet ? !excludeSet.has(key) : !0).map(
+    ([key, value]) => typeof value == "function" ? `(${key})="${formatPropInTemplate(key)}($event)"` : `[${key}]="${formatPropInTemplate(key)}"`
+  ).join(" ");
+}
+
+export {
+  setProjectAnnotations,
+  __definePreview,
+  moduleMetadata,
+  applicationConfig,
+  componentWrapperDecorator,
+  argsToTemplate
+};

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

@@ -0,0 +1,90 @@
+import CJS_COMPAT_NODE_URL_w331jboqnti from 'node:url';
+import CJS_COMPAT_NODE_PATH_w331jboqnti from 'node:path';
+import CJS_COMPAT_NODE_MODULE_w331jboqnti from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_w331jboqnti.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_w331jboqnti.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_w331jboqnti.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// ../../../node_modules/empathic/find.mjs
+import { join as join2 } from "node:path";
+import { existsSync, statSync } from "node:fs";
+
+// ../../../node_modules/empathic/walk.mjs
+import { dirname } from "node:path";
+
+// ../../../node_modules/empathic/resolve.mjs
+import { isAbsolute, join, resolve } from "node:path";
+function absolute(input, root) {
+  return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+
+// ../../../node_modules/empathic/walk.mjs
+function up(base, options) {
+  let { last, cwd } = options || {}, tmp = absolute(base, cwd), root = absolute(last || "/", cwd), prev, arr = [];
+  for (; prev !== root && (arr.push(tmp), tmp = dirname(prev = tmp), tmp !== prev); )
+    ;
+  return arr;
+}
+
+// ../../../node_modules/empathic/find.mjs
+function up2(name, options) {
+  let dir, tmp, start = options && options.cwd || "";
+  for (dir of up(start, options))
+    if (tmp = join2(dir, name), existsSync(tmp)) return tmp;
+}
+
+// ../../../node_modules/empathic/package.mjs
+function up3(options) {
+  return up2("package.json", options);
+}
+
+// src/builders/utils/error-handler.ts
+import { logger, instance as npmLog } from "storybook/internal/node-logger";
+import { dedent } from "ts-dedent";
+var printErrorDetails = (error) => {
+  npmLog.heading = "", error instanceof Error ? error.error ? logger.error(error.error) : error.stats && error.stats.compilation.errors ? error.stats.compilation.errors.forEach((e) => logger.log(e)) : logger.error(error) : error.compilation?.errors && error.compilation.errors.forEach((e) => logger.log(e));
+}, errorSummary = (error) => error.close ? dedent`
+      FATAL broken build!, will close the process,
+      Fix the error below and restart storybook.
+    ` : dedent`
+      Broken build, fix the error above.
+      You may need to refresh the browser.
+    `;
+
+// src/builders/utils/run-compodoc.ts
+import { isAbsolute as isAbsolute2, relative } from "node:path";
+import { JsPackageManagerFactory } from "storybook/internal/common";
+import { prompt } from "storybook/internal/node-logger";
+var hasTsConfigArg = (args) => args.indexOf("-p") !== -1, hasOutputArg = (args) => args.indexOf("-d") !== -1 || args.indexOf("--output") !== -1, toRelativePath = (pathToTsConfig) => isAbsolute2(pathToTsConfig) ? relative(".", pathToTsConfig) : pathToTsConfig, runCompodoc = async ({ compodocArgs, tsconfig }, context) => {
+  let tsConfigPath = toRelativePath(tsconfig), finalCompodocArgs = [
+    "compodoc",
+    ...hasTsConfigArg(compodocArgs) ? [] : ["-p", tsConfigPath],
+    ...hasOutputArg(compodocArgs) ? [] : ["-d", `${context.workspaceRoot || "."}`],
+    ...compodocArgs
+  ], packageManager = JsPackageManagerFactory.getPackageManager();
+  await prompt.executeTaskWithSpinner(
+    () => packageManager.runPackageCommand({
+      args: finalCompodocArgs,
+      cwd: context.workspaceRoot
+    }),
+    {
+      id: "compodoc",
+      intro: "Generating documentation with Compodoc",
+      success: "Compodoc finished successfully",
+      error: "Compodoc failed"
+    }
+  );
+};
+
+export {
+  up2 as up,
+  up3 as up2,
+  printErrorDetails,
+  errorSummary,
+  runCompodoc
+};

package/dist/builders/build-storybook/index.js

@@ -0,0 +1,123 @@
+import CJS_COMPAT_NODE_URL_w331jboqnti from 'node:url';
+import CJS_COMPAT_NODE_PATH_w331jboqnti from 'node:path';
+import CJS_COMPAT_NODE_MODULE_w331jboqnti from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_w331jboqnti.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_w331jboqnti.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_w331jboqnti.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  errorSummary,
+  printErrorDetails,
+  runCompodoc,
+  up,
+  up2
+} from "../../_node-chunks/chunk-R2RNJVE7.js";
+
+// src/builders/build-storybook/index.ts
+import { readFileSync } from "node:fs";
+import { getEnvConfig, getProjectRoot, versions } from "storybook/internal/common";
+import { buildStaticStandalone, withTelemetry } from "storybook/internal/core-server";
+import { addToGlobalContext } from "storybook/internal/telemetry";
+import { logger, logTracker } from "storybook/internal/node-logger";
+import { createBuilder, targetFromTargetString } from "@angular-devkit/architect";
+import { Channel } from "storybook/internal/channels";
+addToGlobalContext("cliVersion", versions.storybook);
+var commandBuilder = async (options, context) => {
+  options.loglevel && logger.setLogLevel(options.loglevel), options.logfile && logTracker.enableLogWriting(), logger.intro("Building Storybook");
+  let { tsConfig } = await setup(options, context), docTSConfig = up("tsconfig.doc.json", {
+    cwd: options.configDir,
+    last: getProjectRoot()
+  });
+  options.compodoc && await runCompodoc(
+    { compodocArgs: options.compodocArgs, tsconfig: docTSConfig ?? tsConfig },
+    context
+  ), getEnvConfig(options, {
+    staticDir: "SBCONFIG_STATIC_DIR",
+    outputDir: "SBCONFIG_OUTPUT_DIR",
+    configDir: "SBCONFIG_CONFIG_DIR"
+  });
+  let {
+    browserTarget,
+    stylePreprocessorOptions,
+    styles,
+    configDir,
+    docs,
+    loglevel,
+    test,
+    outputDir,
+    quiet,
+    enableProdMode = !0,
+    statsJson,
+    disableTelemetry,
+    assets,
+    previewUrl,
+    sourceMap = !1,
+    preserveSymlinks = !1,
+    zoneless = !0
+  } = options, packageJsonPath = up2({ cwd: __dirname }), standaloneOptions = {
+    packageJson: packageJsonPath != null ? JSON.parse(readFileSync(packageJsonPath, "utf8")) : null,
+    configDir,
+    ...docs ? { docs } : {},
+    loglevel,
+    outputDir,
+    test,
+    quiet,
+    enableProdMode,
+    disableTelemetry,
+    angularBrowserTarget: browserTarget,
+    angularBuilderContext: context,
+    angularBuilderOptions: {
+      ...stylePreprocessorOptions ? { stylePreprocessorOptions } : {},
+      ...styles ? { styles } : {},
+      ...assets ? { assets } : {},
+      sourceMap,
+      preserveSymlinks,
+      zoneless
+    },
+    tsConfig,
+    statsJson,
+    previewUrl
+  };
+  if (await runInstance({ ...standaloneOptions, mode: "static" }), logTracker.shouldWriteLogsToFile) {
+    let logFile = await logTracker.writeToFile(options.logfile);
+    logger.info(`Debug logs are written to: ${logFile}`);
+  }
+  return logger.outro("Storybook build completed successfully"), { success: !0 };
+}, build_storybook_default = createBuilder(commandBuilder);
+async function setup(options, context) {
+  let browserOptions, browserTarget;
+  return options.browserTarget && (browserTarget = targetFromTargetString(options.browserTarget), browserOptions = await context.validateOptions(
+    await context.getTargetOptions(browserTarget),
+    await context.getBuilderNameForTarget(browserTarget)
+  )), {
+    tsConfig: options.tsConfig ?? up("tsconfig.json", { cwd: options.configDir, last: getProjectRoot() }) ?? browserOptions.tsConfig
+  };
+}
+async function runInstance(options) {
+  try {
+    await withTelemetry(
+      "build",
+      {
+        cliOptions: options,
+        presetOptions: {
+          ...options,
+          corePresets: [],
+          overridePresets: [],
+          channel: new Channel({})
+        },
+        printError: printErrorDetails
+      },
+      async () => await buildStaticStandalone(options)
+    );
+  } catch (error) {
+    let summary = errorSummary(error);
+    throw new Error(summary);
+  }
+}
+export {
+  build_storybook_default as default
+};