@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/story/collect/analyzer.d.ts

@@ -0,0 +1,33 @@
+import type { AnalyzedComponent, AnalyzedSlot, DirectiveUsage, StoryAnalyzedProp } from '../types';
+/**
+ * Analyze a component file and extract metadata
+ */
+export declare function analyzeComponentFile(filePath: string): Promise<AnalyzedComponent>;
+/**
+ * Analyze component content and extract metadata
+ */
+export declare function analyzeComponent(content: string, name: string, filePath: string): AnalyzedComponent;
+/**
+ * Extract props from script tags using proper tokenization
+ */
+export declare function extractProps(content: string): StoryAnalyzedProp[];
+/**
+ * Extract slots from template
+ */
+export declare function extractSlots(content: string): AnalyzedSlot[];
+/**
+ * Extract component description from comments
+ */
+export declare function extractDescription(content: string): string | undefined;
+/**
+ * Extract component dependencies (other components used)
+ */
+export declare function extractDependencies(content: string): string[];
+/**
+ * Extract CSS classes from template (for Css integration)
+ */
+export declare function extractCssClasses(content: string): string[];
+/**
+ * Extract directive usage from template
+ */
+export declare function extractDirectives(content: string): DirectiveUsage[];

package/dist/story/collect/analyzer.js

@@ -0,0 +1,305 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseScriptDeclarations } from "../../parser/index.js";
+export async function analyzeComponentFile(filePath) {
+  const content = await fs.promises.readFile(filePath, "utf-8"), name = path.basename(filePath, ".stx");
+  return analyzeComponent(content, name, filePath);
+}
+export function analyzeComponent(content, name, filePath) {
+  const props = extractProps(content), slots = extractSlots(content), description = extractDescription(content), dependencies = extractDependencies(content), cssClasses = extractCssClasses(content), directives = extractDirectives(content);
+  return {
+    name,
+    path: filePath,
+    description,
+    props,
+    slots,
+    dependencies,
+    cssClasses,
+    directives
+  };
+}
+export function extractProps(content) {
+  const props = [], scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+  if (!scriptMatch)
+    return props;
+  const scriptContent = scriptMatch[1];
+  try {
+    const declarations = parseScriptDeclarations(scriptContent);
+    for (const decl of declarations) {
+      if (decl.name.startsWith("_"))
+        continue;
+      if (decl.type === "function")
+        continue;
+      const jsdoc = extractJsDocBefore(scriptContent, decl.start), prop = {
+        name: decl.name,
+        type: inferType(decl.value || "", void 0, jsdoc),
+        required: !1,
+        default: decl.value ? parseDefaultValue(decl.value) : void 0
+      };
+      if (jsdoc) {
+        const typeMatch = jsdoc.match(/@type\s+\{([^}]+)\}/i);
+        if (typeMatch) {
+          prop.type = typeMatch[1].trim();
+          if (prop.type.includes("|"))
+            prop.options = prop.type.split("|").map((t) => t.trim().replace(/['"]/g, "")).filter((t) => t !== "");
+        }
+        if (jsdoc.match(/@required/i))
+          prop.required = !0;
+        const descLines = jsdoc.split(`
+`).map((line) => line.trim().replace(/^\*\s*/, "")).filter((line) => !line.startsWith("@") && line.length > 0);
+        if (descLines.length > 0)
+          prop.description = descLines.join(" ").trim();
+      }
+      props.push(prop);
+    }
+  } catch {
+    return extractPropsRegex(scriptContent);
+  }
+  return props;
+}
+function extractJsDocBefore(content, position) {
+  const match = content.slice(0, position).match(/\/\*\*\s*([\s\S]*?)\s*\*\/\s*$/);
+  return match ? match[1] : void 0;
+}
+function extractPropsRegex(scriptContent) {
+  const props = [], propRegex = /(?:\/\*\*\s*([\s\S]*?)\s*\*\/\s*)?(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*([^=]+))?\s*=\s*([^;\n]+)/g;
+  let match = propRegex.exec(scriptContent);
+  while (match !== null) {
+    const [, jsdoc, propName, typeAnnotation, defaultValue] = match;
+    if (propName.startsWith("_"))
+      continue;
+    const prop = {
+      name: propName,
+      type: inferType(defaultValue, typeAnnotation, jsdoc),
+      required: !1,
+      default: parseDefaultValue(defaultValue)
+    };
+    if (jsdoc) {
+      const typeMatch = jsdoc.match(/@type\s+\{([^}]+)\}/i);
+      if (typeMatch) {
+        prop.type = typeMatch[1].trim();
+        if (prop.type.includes("|"))
+          prop.options = prop.type.split("|").map((t) => t.trim().replace(/['"]/g, "")).filter((t) => t !== "");
+      }
+      if (jsdoc.match(/@required/i))
+        prop.required = !0;
+      const descLines = jsdoc.split(`
+`).map((line) => line.trim().replace(/^\*\s*/, "")).filter((line) => !line.startsWith("@") && line.length > 0);
+      if (descLines.length > 0)
+        prop.description = descLines.join(" ").trim();
+    }
+    props.push(prop);
+    match = propRegex.exec(scriptContent);
+  }
+  return props;
+}
+function inferType(defaultValue, typeAnnotation, jsdoc) {
+  if (jsdoc) {
+    const typeMatch = jsdoc.match(/@type\s+\{([^}]+)\}/i);
+    if (typeMatch)
+      return typeMatch[1].trim();
+  }
+  if (typeAnnotation)
+    return typeAnnotation.trim();
+  const trimmed = defaultValue.trim();
+  if (trimmed === "true" || trimmed === "false")
+    return "boolean";
+  if (/^['"`]/.test(trimmed))
+    return "string";
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+    return "number";
+  if (trimmed.startsWith("["))
+    return "array";
+  if (trimmed.startsWith("{"))
+    return "object";
+  if (trimmed === "null")
+    return "null";
+  if (trimmed === "undefined")
+    return "undefined";
+  return "any";
+}
+function parseDefaultValue(value) {
+  const trimmed = value.trim();
+  try {
+    if (trimmed === "true")
+      return !0;
+    if (trimmed === "false")
+      return !1;
+    if (trimmed === "null")
+      return null;
+    if (trimmed === "undefined")
+      return;
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+      return Number(trimmed);
+    if (/^['"`].*['"`]$/.test(trimmed))
+      return trimmed.slice(1, -1);
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+      const jsonStr = trimmed.replace(/'/g, '"');
+      try {
+        return JSON.parse(jsonStr);
+      } catch {
+        return trimmed;
+      }
+    }
+    return trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+export function extractSlots(content) {
+  const slots = [], seenSlots = new Set;
+  if (/\{\{\s*slot\s*\}\}/.test(content)) {
+    slots.push({ name: "default" });
+    seenSlots.add("default");
+  }
+  const slotTagRegex = /<slot\s*(?:name\s*=\s*["']([^"']+)["'])?\s*\/?>/gi;
+  let match = slotTagRegex.exec(content);
+  while (match !== null) {
+    const slotName = match[1] || "default";
+    if (!seenSlots.has(slotName)) {
+      slots.push({ name: slotName });
+      seenSlots.add(slotName);
+    }
+    match = slotTagRegex.exec(content);
+  }
+  return slots;
+}
+export function extractDescription(content) {
+  const htmlCommentMatch = content.match(/^\s*<!--\s*([\s\S]*?)\s*-->/);
+  if (htmlCommentMatch)
+    return htmlCommentMatch[1].trim();
+  const scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+  if (scriptMatch) {
+    const jsdocMatch = scriptMatch[1].match(/^\s*\/\*\*\s*([\s\S]*?)\s*\*\//);
+    if (jsdocMatch) {
+      const descLines = jsdocMatch[1].split(`
+`).map((line) => line.trim().replace(/^\*\s*/, "")).filter((line) => !line.startsWith("@") && line.length > 0);
+      if (descLines.length > 0)
+        return descLines.join(" ").trim();
+    }
+  }
+  return;
+}
+export function extractDependencies(content) {
+  const deps = [], seen = new Set, importRegex = /import\s+(\w+)\s+from\s+['"][^'"]+\.stx['"]/g;
+  let match = importRegex.exec(content);
+  while (match !== null) {
+    const componentName = match[1];
+    if (!seen.has(componentName)) {
+      deps.push(componentName);
+      seen.add(componentName);
+    }
+    match = importRegex.exec(content);
+  }
+  const componentTagRegex = /<([A-Z][a-zA-Z0-9]*)\b/g;
+  match = componentTagRegex.exec(content);
+  while (match !== null) {
+    const componentName = match[1];
+    if (!seen.has(componentName)) {
+      deps.push(componentName);
+      seen.add(componentName);
+    }
+    match = componentTagRegex.exec(content);
+  }
+  const componentDirectiveRegex = /@component\s*\(\s*['"]([^'"]+)['"]/g;
+  match = componentDirectiveRegex.exec(content);
+  while (match !== null) {
+    const componentName = match[1];
+    if (!seen.has(componentName)) {
+      deps.push(componentName);
+      seen.add(componentName);
+    }
+    match = componentDirectiveRegex.exec(content);
+  }
+  return deps;
+}
+export function extractCssClasses(content) {
+  const classes = [], seen = new Set, classRegex = /class\s*=\s*["']([^"']+)["']/gi;
+  let match = classRegex.exec(content);
+  while (match !== null) {
+    const classValue = match[1];
+    for (const cls of classValue.split(/\s+/)) {
+      const trimmed = cls.trim();
+      if (trimmed && !trimmed.includes("{{") && !seen.has(trimmed)) {
+        classes.push(trimmed);
+        seen.add(trimmed);
+      }
+    }
+    match = classRegex.exec(content);
+  }
+  return classes;
+}
+export function extractDirectives(content) {
+  const directives = new Map, directivePatterns = [
+    "@if",
+    "@else",
+    "@elseif",
+    "@endif",
+    "@unless",
+    "@endunless",
+    "@foreach",
+    "@endforeach",
+    "@for",
+    "@endfor",
+    "@while",
+    "@endwhile",
+    "@switch",
+    "@case",
+    "@default",
+    "@endswitch",
+    "@component",
+    "@endcomponent",
+    "@slot",
+    "@endslot",
+    "@include",
+    "@layout",
+    "@extends",
+    "@section",
+    "@endsection",
+    "@yield",
+    "@push",
+    "@endpush",
+    "@stack",
+    "@once",
+    "@endonce",
+    "@auth",
+    "@endauth",
+    "@guest",
+    "@endguest",
+    "@can",
+    "@endcan",
+    "@cannot",
+    "@endcannot",
+    "@env",
+    "@endenv",
+    "@production",
+    "@endproduction",
+    "@js",
+    "@endjs",
+    "@ts",
+    "@endts",
+    "@css",
+    "@endcss",
+    "@json",
+    "@class",
+    "@style",
+    "@checked",
+    "@selected",
+    "@disabled",
+    "@readonly",
+    "@required"
+  ];
+  for (const directive of directivePatterns) {
+    const regex = new RegExp(directive.replace("@", "@"), "gi"), matches = content.match(regex);
+    if (matches && matches.length > 0) {
+      const name = directive.slice(1);
+      if (!name.startsWith("end"))
+        directives.set(name, (directives.get(name) || 0) + matches.length);
+    }
+  }
+  const result = [];
+  for (const [name, count] of directives)
+    result.push({ name, count });
+  result.sort((a, b) => b.count - a.count);
+  return result;
+}

package/dist/story/collect/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * STX Story - Collection module
+ * Discovers and analyzes story files
+ */
+export {
+  analyzeComponent,
+  analyzeComponentFile,
+  extractCssClasses,
+  extractDependencies,
+  extractDescription,
+  extractDirectives,
+  extractProps,
+  extractSlots,
+} from './analyzer';
+export {
+  extractScriptContent,
+  extractTemplateContent,
+  parseStoryContent,
+  parseStoryFile,
+} from './parser';
+export {
+  isNonComponentFile,
+  scanStoryFiles,
+  watchStoryFiles,
+} from './scanner';
+export {
+  buildTree,
+  createTreePath,
+  findStoryInTree,
+  flattenTree,
+} from './tree';

package/dist/story/collect/index.js

@@ -0,0 +1,27 @@
+export {
+  analyzeComponent,
+  analyzeComponentFile,
+  extractCssClasses,
+  extractDependencies,
+  extractDescription,
+  extractDirectives,
+  extractProps,
+  extractSlots
+} from "./analyzer.js";
+export {
+  extractScriptContent,
+  extractTemplateContent,
+  parseStoryContent,
+  parseStoryFile
+} from "./parser.js";
+export {
+  isNonComponentFile,
+  scanStoryFiles,
+  watchStoryFiles
+} from "./scanner.js";
+export {
+  buildTree,
+  createTreePath,
+  findStoryInTree,
+  flattenTree
+} from "./tree.js";

package/dist/story/collect/parser.d.ts

@@ -0,0 +1,17 @@
+import type { ServerStory } from '../types';
+/**
+ * Parse a story file and extract story definitions
+ */
+export declare function parseStoryFile(filePath: string): Promise<ServerStory | null>;
+/**
+ * Parse story content and extract story definitions
+ */
+export declare function parseStoryContent(content: string, filePath: string): ServerStory | null;
+/**
+ * Extract script content from a story file
+ */
+export declare function extractScriptContent(content: string): string;
+/**
+ * Extract template content from a story file (everything outside script tags)
+ */
+export declare function extractTemplateContent(content: string): string;

package/dist/story/collect/parser.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+export async function parseStoryFile(filePath) {
+  const content = await fs.promises.readFile(filePath, "utf-8");
+  return parseStoryContent(content, filePath);
+}
+export function parseStoryContent(content, filePath) {
+  const storyMatch = content.match(/<Story\s+([^>]*)>([\s\S]*?)<\/Story>/i);
+  if (!storyMatch)
+    return null;
+  const storyAttrs = storyMatch[1], storyContent = storyMatch[2], title = extractAttribute(storyAttrs, "title") || extractFileTitle(filePath), id = generateId(title), group = extractAttribute(storyAttrs, "group"), icon = extractAttribute(storyAttrs, "icon"), iconColor = extractAttribute(storyAttrs, "icon-color") || extractAttribute(storyAttrs, "iconColor"), docsOnly = extractAttribute(storyAttrs, "docs-only") === "true" || extractAttribute(storyAttrs, "docsOnly") === "true", layout = parseLayout(storyAttrs), variants = extractVariants(storyContent);
+  return {
+    id,
+    title,
+    group,
+    variants,
+    layout,
+    icon,
+    iconColor,
+    docsOnly
+  };
+}
+function extractVariants(content) {
+  const variants = [], variantRegex = /<Variant\s+([^>]*)>([\s\S]*?)<\/Variant>/gi;
+  let match = variantRegex.exec(content);
+  while (match !== null) {
+    const attrs = match[1], variantContent = match[2], title = extractAttribute(attrs, "title") || "Default", id = generateId(title), icon = extractAttribute(attrs, "icon"), iconColor = extractAttribute(attrs, "icon-color") || extractAttribute(attrs, "iconColor"), responsiveDisabled = extractAttribute(attrs, "responsive-disabled") === "true", initStateAttr = extractAttribute(attrs, ":init-state") || extractAttribute(attrs, "init-state"), state = initStateAttr ? parseInitState(content, initStateAttr) : {}, source = extractVariantSource(variantContent);
+    variants.push({
+      id,
+      title,
+      icon,
+      iconColor,
+      state,
+      source,
+      responsiveDisabled
+    });
+    match = variantRegex.exec(content);
+  }
+  if (variants.length === 0)
+    variants.push({
+      id: "default",
+      title: "Default",
+      state: {}
+    });
+  return variants;
+}
+function extractAttribute(attrs, name) {
+  const patterns = [
+    new RegExp(`:${name}\\s*=\\s*["']([^"']+)["']`, "i"),
+    new RegExp(`${name}\\s*=\\s*["']([^"']+)["']`, "i"),
+    new RegExp(`:${name}\\s*=\\s*"([^"]+)"`, "i"),
+    new RegExp(`${name}\\s*=\\s*"([^"]+)"`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = attrs.match(pattern);
+    if (match)
+      return match[1];
+  }
+  return;
+}
+function parseLayout(attrs) {
+  const layoutAttr = extractAttribute(attrs, ":layout") || extractAttribute(attrs, "layout");
+  if (!layoutAttr)
+    return;
+  try {
+    const normalized = layoutAttr.replace(/'/g, '"').replace(/(\w+):/g, '"$1":');
+    return JSON.parse(normalized);
+  } catch {
+    return { type: "single" };
+  }
+}
+function parseInitState(fullContent, funcName) {
+  const scriptMatch = fullContent.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!scriptMatch)
+    return {};
+  const scriptContent = scriptMatch[1], funcRegex = new RegExp(`function\\s+${funcName}\\s*\\(\\)\\s*\\{([\\s\\S]*?)\\breturn\\s*\\{([\\s\\S]*?)\\}`, "i"), funcMatch = scriptContent.match(funcRegex);
+  if (!funcMatch) {
+    const arrowRegex = new RegExp(`(?:const|let|var)\\s+${funcName}\\s*=\\s*\\(\\)\\s*=>\\s*\\(\\{([\\s\\S]*?)\\}\\)`, "i"), arrowMatch = scriptContent.match(arrowRegex);
+    if (arrowMatch)
+      return parseObjectLiteral(arrowMatch[1]);
+    return {};
+  }
+  return parseObjectLiteral(funcMatch[2]);
+}
+function parseObjectLiteral(objStr) {
+  const result = {}, pairRegex = /(\w+)\s*:\s*([^,\n]+)/g;
+  let match = pairRegex.exec(objStr);
+  while (match !== null) {
+    const key = match[1], valueStr = match[2].trim();
+    result[key] = parseValue(valueStr);
+    match = pairRegex.exec(objStr);
+  }
+  return result;
+}
+function parseValue(valueStr) {
+  const trimmed = valueStr.trim();
+  if (trimmed === "true")
+    return !0;
+  if (trimmed === "false")
+    return !1;
+  if (trimmed === "null")
+    return null;
+  if (trimmed === "undefined")
+    return;
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+    return Number(trimmed);
+  if (/^['"].*['"]$/.test(trimmed))
+    return trimmed.slice(1, -1);
+  return trimmed;
+}
+function extractVariantSource(content) {
+  let source = content;
+  source = source.replace(/<template\s+#default[^>]*>([\s\S]*?)<\/template>/gi, "$1");
+  source = source.replace(/<template\s+#controls[^>]*>[\s\S]*?<\/template>/gi, "");
+  source = source.trim();
+  return source;
+}
+function extractFileTitle(filePath) {
+  return (filePath.split("/").pop() || filePath).replace(/\.story\.stx$/i, "").replace(/([A-Z])/g, " $1").trim();
+}
+function generateId(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export function extractScriptContent(content) {
+  const match = content.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  return match ? match[1] : "";
+}
+export function extractTemplateContent(content) {
+  return content.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").trim();
+}

package/dist/story/collect/scanner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * STX Story - Story file scanner
+ * Discovers .story.stx files in the project
+ */
+import type { ServerStoryFile, StoryContext } from '../types';
+/**
+ * Scan for story files matching the configured patterns
+ */
+export declare function scanStoryFiles(ctx: StoryContext): Promise<ServerStoryFile[]>;
+/**
+ * Check if a file is a non-component file (layout, page, partial)
+ */
+export declare function isNonComponentFile(relativePath: string): boolean;
+/**
+ * Watch for story file changes
+ */
+export declare function watchStoryFiles(ctx: StoryContext, onChange: (event: 'add' | 'change' | 'unlink', file: ServerStoryFile) => void): () => void;

package/dist/story/collect/scanner.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function scanStoryFiles(ctx) {
+  const { root, config } = ctx, storyFiles = [], files = await findMatchingFiles(root, config.storyMatch, config.storyIgnored);
+  for (const relativePath of files) {
+    const absolutePath = path.resolve(root, relativePath), storyFile = createStoryFile(relativePath, absolutePath);
+    storyFiles.push(storyFile);
+  }
+  return storyFiles;
+}
+async function findMatchingFiles(root, patterns, ignored) {
+  const results = [];
+  async function walkDir(dir, baseDir) {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: !0 });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name), relativePath = path.relative(baseDir, fullPath);
+      if (isIgnored(relativePath, ignored))
+        continue;
+      if (entry.isDirectory())
+        await walkDir(fullPath, baseDir);
+      else if (entry.isFile()) {
+        if (matchesPatterns(relativePath, patterns))
+          results.push(relativePath);
+      }
+    }
+  }
+  await walkDir(root, root);
+  return results;
+}
+function isIgnored(relativePath, ignored) {
+  for (const pattern of ignored)
+    if (matchGlob(relativePath, pattern))
+      return !0;
+  return !1;
+}
+const NON_COMPONENT_PATTERNS = [
+  "**/layouts/**",
+  "**/pages/**",
+  "**/partials/**",
+  "**/_*.stx",
+  "**/layout.stx",
+  "**/page.stx",
+  "**/error.stx",
+  "**/loading.stx"
+];
+export function isNonComponentFile(relativePath) {
+  for (const pattern of NON_COMPONENT_PATTERNS)
+    if (matchGlob(relativePath, pattern))
+      return !0;
+  return !1;
+}
+function matchesPatterns(relativePath, patterns) {
+  for (const pattern of patterns)
+    if (matchGlob(relativePath, pattern))
+      return !0;
+  return !1;
+}
+function matchGlob(str, pattern) {
+  const normalizedStr = str.replace(/\\/g, "/");
+  let regexStr = pattern.replace(/\\/g, "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  regexStr = `^${regexStr}$`;
+  return new RegExp(regexStr).test(normalizedStr);
+}
+function createStoryFile(relativePath, absolutePath) {
+  const fileName = path.basename(relativePath, ".story.stx");
+  return {
+    id: relativePath.toLowerCase().replace(/\.story\.stx$/, "").replace(/[/\\]/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, ""),
+    path: absolutePath,
+    relativePath,
+    fileName,
+    treeFile: {
+      title: fileName,
+      path: relativePath
+    }
+  };
+}
+export function watchStoryFiles(ctx, onChange) {
+  const { root, config } = ctx, watchers = [], watcher = fs.watch(root, { recursive: !0 }, async (eventType, filename) => {
+    if (!filename)
+      return;
+    const relativePath = filename.replace(/\\/g, "/");
+    if (!matchesPatterns(relativePath, config.storyMatch))
+      return;
+    if (isIgnored(relativePath, config.storyIgnored))
+      return;
+    const absolutePath = path.resolve(root, relativePath);
+    try {
+      await fs.promises.access(absolutePath);
+      const storyFile = createStoryFile(relativePath, absolutePath);
+      onChange(eventType === "rename" ? "add" : "change", storyFile);
+    } catch {
+      const storyFile = createStoryFile(relativePath, absolutePath);
+      onChange("unlink", storyFile);
+    }
+  });
+  watchers.push(watcher);
+  return () => {
+    for (const w of watchers)
+      w.close();
+  };
+}

package/dist/story/collect/tree.d.ts

@@ -0,0 +1,24 @@
+/**
+ * STX Story - Tree builder
+ * Builds the navigation tree from story files
+ */
+import type { ResolvedStoryConfig, ServerStoryFile, ServerTree, ServerTreeLeaf } from '../types';
+/**
+ * Create tree path from a story file
+ */
+export declare function createTreePath(config: ResolvedStoryConfig, file: ServerStoryFile): string[];
+/**
+ * Build the navigation tree from story files
+ */
+export declare function buildTree(config: ResolvedStoryConfig, files: ServerStoryFile[]): ServerTree;
+/**
+ * Flatten tree to get all leaf indices in order
+ */
+export declare function flattenTree(tree: ServerTree): number[];
+/**
+ * Find a story in the tree by index
+ */
+export declare function findStoryInTree(tree: ServerTree, index: number): {
+    path: string[];
+    node: ServerTreeLeaf;
+} | null;