forgebook 0.2.0 → 0.3.0

package/dist/src/vite/storyFilesModule.js

@@ -1,72 +1,95 @@
 /**
- * The module that answers a `?forgebook-files` import: every story file a pattern matches, as one module with each
- * file's index (read from its source, never run), the loaders of its module, its component's docs and its code, and
- * the group's "Used in" loader.
+ * The module that answers a group of story files: a `?forgebook-files` import's pattern, or a catalogue's `stories`
+ * list (`FILES_SPECIFIER_PREFIX`). Every story file the group lists, as one module with each file's index (read from
+ * its source, never run), the loaders of its module, its component's docs and its code, and the group's "Used in"
+ * loader.
  *
  * @remarks
- * One module per pattern, instead of an import per file: in development the browser fetched every index module one by
- * one, a few hundred requests per frame. The keys are the files' paths relative to the declaring module
+ * One module per group, instead of an import per file: in development the browser fetched every index module one by
+ * one, a few hundred requests per frame. A catalogue's `stories` are one group, not one per pattern: its `!` patterns
+ * leave files out of what all the others list, a file two patterns list is listed once, and "Used in" joins stories
+ * across every pattern. The keys are the files' paths relative to the declaring module
  * (`../src/x.stories.tsx`), the same keys `storyFileKeys` gives the tests that read the files from the disk. A build
  * takes each file's docs, code and page from the group's texts module, written as data, instead of their loaders'
  * imports (`builtTexts.ts`).
  *
  * @module
  */
-import { globSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { codeLiteral } from "../codeLiteral.js";
 import { autoTitle, patternBase } from "./autoTitle.js";
 import { isSettledSince, nowNs, stampPaths } from "./diskCache.js";
 import { indexStoryFile } from "./indexStoryFile.js";
+import { isNegated, listedFiles } from "./storyPatterns.js";
 import { VITE_PATHS } from "./vitePaths.js";
 /** Between a group's parts in a module's id: no path or pattern holds it. */
-const GROUP_SEPARATOR = "::";
+export const GROUP_SEPARATOR = "::";
+/** Before a pattern's count of climbed folders in a module's id, when it is a `!` pattern. */
+const NEGATED_MARK = "!";
 /**
- * A `?forgebook-files` group written for a module's id: the folder, how many folders the pattern climbs, and the rest
- * of the pattern. A Vite module's id is served under a URL path, whose normalisation would let a `..` remove the part
- * before it (`app::../storybook`: the folder and the separator), so the pattern's leading `../` are counted, never
- * written. The files keep their keys relative to the declaring module (`../src/x.stories.tsx`), unique in a source and
- * the testing package's too.
+ * One pattern written for a module's id: whether it leaves files out and how many folders it climbs, then the rest of
+ * it. The mark goes with the count, never with the rest, which may start with an extglob's `!(…)`.
  *
- * @param folder - the declaring module's folder.
  * @param pattern - the pattern as the import writes it (`../src/**\/*.stories.tsx`).
  */
-export const storyFilesGroupText = (folder, pattern) => {
-    const segments = pattern.split("/");
+const patternParts = (pattern) => {
+    const isLeftOut = isNegated(pattern);
+    const segments = (isLeftOut ? pattern.slice(1) : pattern).split("/");
     const firstOwn = segments.findIndex((segment) => segment !== "." && segment !== "..");
     const climbed = firstOwn === -1 ? segments : segments.slice(0, firstOwn);
     const own = firstOwn === -1 ? [] : segments.slice(firstOwn);
     const up = climbed.filter((segment) => segment === "..").length;
-    return [folder, String(up), own.join("/")].join(GROUP_SEPARATOR);
+    return [`${isLeftOut ? NEGATED_MARK : ""}${up}`, own.join("/")];
 };
+/**
+ * A group of story files written for a module's id: the folder, then for each pattern how many folders it climbs and
+ * the rest of it. A Vite module's id is served under a URL path, whose normalisation would let a `..` remove the part
+ * before it (`app::../storybook`: the folder and the separator), so a pattern's leading `../` are counted, never
+ * written. The files keep their keys relative to the declaring module (`../src/x.stories.tsx`), unique in a source and
+ * the testing package's too.
+ *
+ * @param folder - the declaring module's folder.
+ * @param patterns - the patterns as the import or the configuration writes them (`../src/**\/*.stories.tsx`).
+ */
+export const storyFilesGroupText = (folder, patterns) => [folder, ...patterns.flatMap(patternParts)].join(GROUP_SEPARATOR);
 /**
  * A group read back from a module's id (`storyFilesGroupText`).
  *
  * @param text - the id's group part.
  */
 export const storyFilesGroupOf = (text) => {
-    const [root = "", up = "0", own = ""] = text.split(GROUP_SEPARATOR);
-    return { root, pattern: `${"../".repeat(Number(up))}${own}` };
+    const [root = "", ...parts] = text.split(GROUP_SEPARATOR);
+    const patterns = [];
+    for (let at = 0; at < parts.length; at += 2) {
+        const count = parts[at] ?? "0";
+        const isLeftOut = count.startsWith(NEGATED_MARK);
+        const up = Number(isLeftOut ? count.slice(NEGATED_MARK.length) : count);
+        patterns.push(`${isLeftOut ? "!" : ""}${"../".repeat(up)}${parts[at + 1] ?? ""}`);
+    }
+    return { root, patterns };
 };
-/** The folder of a project's dependencies. */
-const DEPENDENCIES = "node_modules";
+/** Every file a group lists: a build's, and a test's that reads the files from the disk. */
+export const EVERY_FILE = () => true;
 /**
- * What a pattern leaves out: the dependencies, unless it names them. A `**` from a monorepo's root would otherwise walk
- * every package's, seconds on the server's thread for files nobody asked for, as Storybook's own globs skip them.
+ * The story files patterns list, as paths relative to `root` starting with `./` or `../`, each once, sorted: the union
+ * of the patterns less what the `!` ones match (`listedFiles`).
  *
- * @param pattern - the pattern.
+ * @param root - the folder the patterns are relative to: the declaring module's.
+ * @param patterns - the patterns (`../src/**\/*.stories.tsx`, `!../src/**\/legacy/*`).
+ * @param isKept - whether a listed file may be read; every one by default.
+ * @throws when every pattern is a `!` one.
  */
-const excludedFrom = (pattern) => pattern.includes(DEPENDENCIES) ? () => false : (name) => name === DEPENDENCIES;
+export const storyFileKeys = (root, patterns, isKept = EVERY_FILE) => listedFiles(root, patterns)
+    .map((file) => file.key)
+    .filter((key) => isKept(VITE_PATHS.resolve(root, key)));
 /**
- * The story files patterns match, as paths relative to `root` starting with `./` or `../`, sorted.
- *
- * @param root - the folder the patterns are relative to: the declaring module's.
- * @param patterns - the patterns (`../src/**\/*.stories.tsx`).
+ * The specifier prefix of a group of story files named by its patterns, the group following (`storyFilesGroupText`):
+ * how the module generated for a catalogue's `stories` imports them as one group, `!` patterns included, which a
+ * `?forgebook-files` import of one pattern cannot say.
  */
-export const storyFileKeys = (root, patterns) => patterns
-    .flatMap((pattern) => globSync(pattern, { cwd: root, exclude: excludedFrom(pattern) }))
-    // with forward slashes on every system, so a story file has the same key wherever the catalogue runs
-    .map((file) => VITE_PATHS.relativeKey(root, file))
-    .sort();
+export const FILES_SPECIFIER_PREFIX = "virtual:forgebook-files:";
+/** The specifier prefix of a group of docs pages named by its patterns, the same way: a catalogue's `docs`. */
+export const DOCS_PAGES_SPECIFIER_PREFIX = "virtual:forgebook-docs-pages:";
 /**
  * The id prefix of a group's "Used in" module: the group follows (`storyFilesGroupText`), as in a `?forgebook-files`
  * module's id. The plugin answers it (`usageModule.ts`) only when a page asks.
@@ -89,14 +112,14 @@ export const TEXTS_PREFIX = "virtual:forgebook-texts:";
  * it, so a page that shows "Used in" never downloads it.
  */
 export const REACH_PREFIX = "virtual:forgebook-reach:";
-/** Whether what a cache file holds is a pattern's index. */
+/** Whether what a cache file holds is a group's index. */
 export const isKeptIndex = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
- * One story file a pattern matches, indexed from its text on disk, with the title its path makes when it writes none.
+ * One story file a pattern lists, indexed from its text on disk, with the title its path makes when it writes none.
  *
  * @internal
  * @param root - the declaring module's folder.
- * @param pattern - the pattern.
+ * @param pattern - the pattern that lists it.
  * @param key - the file's path relative to the declaring module.
  * @returns the index, or a message saying why the file cannot be indexed.
  */
@@ -106,28 +129,30 @@ export const storyFileIndex = (root, pattern, key) => {
     return indexStoryFile(file, readFileSync(file, "utf8"), title === undefined ? {} : { autoTitle: title });
 };
 /**
- * Every story file a pattern matches, indexed.
+ * Every story file a group's patterns list, indexed.
  *
  * @param root - the declaring module's folder.
- * @param pattern - the pattern.
+ * @param patterns - the patterns (`storyFileKeys`).
  * @param watch - adds a file whose edit renews the module that read it.
  * @param cache - the index kept between starts, which holds while the files it came from do; none reads them all.
+ * @param isKept - whether a listed file may be read; every one by default.
  * @throws when a story file cannot be indexed.
  */
-export const indexedStoryFiles = (root, pattern, watch, cache) => {
-    const name = storyFilesGroupText(VITE_PATHS.normalize(root), pattern);
+export const indexedStoryFiles = (root, patterns, watch, cache, isKept = EVERY_FILE) => {
+    const name = storyFilesGroupText(VITE_PATHS.normalize(root), patterns);
     const since = nowNs();
     const kept = cache?.read(name);
-    const files = storyFileKeys(root, [pattern]).map((key) => {
+    const listed = listedFiles(root, patterns).filter(({ key }) => isKept(VITE_PATHS.resolve(root, key)));
+    const files = listed.map(({ key, pattern }) => {
         const file = VITE_PATHS.resolve(root, key);
         watch(file);
         const known = kept?.[key];
         if (known !== undefined)
-            return { key, file, index: known };
+            return { key, pattern, file, index: known };
         const index = storyFileIndex(root, pattern, key);
         if (typeof index === "string")
             throw new Error(index);
-        return { key, file, index };
+        return { key, pattern, file, index };
     });
     // kept again when anything was read anew: a file added, or the kept index out of date
     if (cache !== undefined && files.some(({ key }) => kept?.[key] === undefined)) {
@@ -139,35 +164,35 @@ export const indexedStoryFiles = (root, pattern, watch, cache) => {
     return files;
 };
 /**
- * The code of the module for one pattern.
+ * The code of the module for one group.
  *
  * @param root - the declaring module's folder.
- * @param pattern - the pattern before `?forgebook-files`.
+ * @param patterns - the group's patterns.
  * @param watch - adds a file whose edit renews the module (each story file: its index is in the module).
- * @param loaders - the group's loaders besides its story files'; both by default.
+ * @param loaders - the group's loaders besides its story files'; all of them by default.
  * @param cache - the index kept between starts.
  * @returns the module's code, or a message saying which file cannot be indexed.
  */
-export const storyFilesModule = (root, pattern, watch, loaders = { hasUsage: true, hasReach: true }, cache) => storyFilesCode(root, pattern, indexedStoryFiles(root, pattern, watch, cache), loaders);
+export const storyFilesModule = (root, patterns, watch, loaders = { hasUsage: true, hasReach: true }, cache) => storyFilesCode(root, patterns, indexedStoryFiles(root, patterns, watch, cache), loaders);
 /**
- * The code of the module for one pattern, from its story files indexed.
+ * The code of the module for one group, from its story files indexed.
  *
  * @internal
  * @param root - the declaring module's folder.
- * @param pattern - the pattern before `?forgebook-files`.
- * @param files - the story files it matches, indexed.
+ * @param patterns - the group's patterns.
+ * @param files - the story files it lists, indexed.
  * @param loaders - the group's loaders besides its story files'.
  * @param hasTexts - a build's: whether each file's docs, code and page come from the group's texts module, in the
  * rows' order (`TEXTS_PREFIX`), and not each from its query.
  */
-export const storyFilesCode = (root, pattern, files, loaders, hasTexts = false) => {
-    const { hasUsage, hasReach } = loaders;
+export const storyFilesCode = (root, patterns, files, loaders, hasTexts = false) => {
+    const { hasDocs = true, hasUsage, hasReach } = loaders;
     // the group's id in Vite's form, as the plugin names the declaring module's folder
     const folder = VITE_PATHS.normalize(root);
-    const usage = codeLiteral(`${USAGE_PREFIX}${storyFilesGroupText(folder, pattern)}`);
-    const search = codeLiteral(`${SEARCH_PREFIX}${storyFilesGroupText(folder, pattern)}`);
-    const reach = codeLiteral(`${REACH_PREFIX}${storyFilesGroupText(folder, pattern)}`);
-    const texts = codeLiteral(`${TEXTS_PREFIX}${storyFilesGroupText(folder, pattern)}`);
+    const usage = codeLiteral(`${USAGE_PREFIX}${storyFilesGroupText(folder, patterns)}`);
+    const search = codeLiteral(`${SEARCH_PREFIX}${storyFilesGroupText(folder, patterns)}`);
+    const reach = codeLiteral(`${REACH_PREFIX}${storyFilesGroupText(folder, patterns)}`);
+    const texts = codeLiteral(`${TEXTS_PREFIX}${storyFilesGroupText(folder, patterns)}`);
     // absolute paths in Vite's form: the module has no folder of its own, Vite serves them under /@fs/ in development,
     // and the queries' ids come back to the plugin as written here
     const absolute = (key) => VITE_PATHS.resolve(folder, key);
@@ -175,7 +200,12 @@ export const storyFilesCode = (root, pattern, files, loaders, hasTexts = false)
     const query = (key, name) => `() => import(${codeLiteral(`${absolute(key)}?${name}`)}).then((module) => module.default)`;
     const textLoaders = (key) => hasTexts
         ? []
-        : [query(key, "forgebook-docs"), query(key, "forgebook-code"), query(key, "forgebook-page")];
+        : // the docs' place is kept without them, so every row's columns stay where the module reads them
+            [
+                hasDocs ? query(key, "forgebook-docs") : "null",
+                query(key, "forgebook-code"),
+                query(key, "forgebook-page")
+            ];
     // a row per file, its name written once and not once per column (its index, each loader): a large catalogue's
     // names are a tenth of its index
     const rows = files.map(({ key, index }) => [codeLiteral(key), codeLiteral(index), `() => import(${path(key)})`, ...textLoaders(key)].join(", "));
@@ -188,7 +218,7 @@ export const storyFilesCode = (root, pattern, files, loaders, hasTexts = false)
         "export default {",
         "index: column(1),",
         "stories: column(2),",
-        "docs: column(3),",
+        hasDocs ? "docs: column(3)," : "docs: {},",
         "code: column(4),",
         "pages: column(5),",
         `search: () => import(${search}).then((module) => module.default),`,

package/dist/src/vite/storyPatterns.d.ts

@@ -0,0 +1,39 @@
+import { type VitePaths } from "./vitePaths.ts";
+/**
+ * Whether a pattern leaves files out (`!src/**\/legacy/*`) rather than listing them. One that starts with an extglob's
+ * `!(…)` lists the names its group does not match, as fast-glob reads it.
+ *
+ * @param pattern - the pattern.
+ */
+export declare const isNegated: (pattern: string) => boolean;
+/**
+ * Why a list of patterns lists nothing by construction, or none: every pattern in it is a `!` one, which only leaves
+ * files out of what the others list.
+ *
+ * @param patterns - the patterns.
+ */
+export declare const patternsProblem: (patterns: readonly string[]) => string | undefined;
+/**
+ * The paths one pattern matches, as Node's `globSync` gives them (backslashes on Windows), relative to the folder.
+ *
+ * @param root - the folder the pattern is relative to.
+ * @param pattern - the pattern, without a `!`.
+ */
+export type FindFiles = (root: string, pattern: string) => readonly string[];
+/** A file a list of patterns lists, with the pattern that lists it. */
+export type ListedFile = {
+    /** Its path relative to the patterns' folder, starting with `./` or `../`, with forward slashes. */
+    readonly key: string;
+    /** The first pattern that lists it: its static start begins the file's title when its meta writes none. */
+    readonly pattern: string;
+};
+/**
+ * The files a list of patterns lists, each once, sorted by key.
+ *
+ * @param root - the folder the patterns are relative to: the declaring module's.
+ * @param patterns - the patterns (`../src/**\/*.stories.tsx`, `!../src/**\/legacy/*`), in any order.
+ * @param find - what matches one pattern; the disk's by default, another system's in a test.
+ * @param paths - the path functions; the running system's unless a test names another.
+ * @throws when every pattern is a `!` one (`patternsProblem`).
+ */
+export declare const listedFiles: (root: string, patterns: readonly string[], find?: FindFiles, paths?: VitePaths) => ListedFile[];

package/dist/src/vite/storyPatterns.js

@@ -0,0 +1,100 @@
+/**
+ * The files a list of patterns names, as Vite's `import.meta.glob` and fast-glob read one: the union of its patterns,
+ * less what its `!` patterns match, whatever their order. Used for a catalogue's story files and docs pages, by the
+ * plugin and by the testing package, so both list the same files.
+ *
+ * @remarks
+ * A `!` pattern is matched by the same engine as the others (Node's `globSync`), from the same folder, so it follows
+ * the same syntax: `!src/**\/legacy/*.stories.tsx` leaves out what `src/**\/legacy/*.stories.tsx` would list, and one
+ * that matches a folder (`!src/drafts`) leaves out every file in it, as fast-glob does. A file two
+ * patterns list is listed once, by the first, whose static start begins its title (as Storybook's first specifier
+ * does). A list of `!` patterns alone lists nothing, which is a mistake, never what its author meant: it is refused.
+ *
+ * @module
+ */
+import { globSync } from "node:fs";
+import { VITE_PATHS } from "./vitePaths.js";
+/** What starts a pattern that leaves files out. */
+const NEGATION = "!";
+/**
+ * Whether a pattern leaves files out (`!src/**\/legacy/*`) rather than listing them. One that starts with an extglob's
+ * `!(…)` lists the names its group does not match, as fast-glob reads it.
+ *
+ * @param pattern - the pattern.
+ */
+export const isNegated = (pattern) => pattern.startsWith(NEGATION) && !pattern.startsWith(`${NEGATION}(`);
+/**
+ * Why a list of patterns lists nothing by construction, or none: every pattern in it is a `!` one, which only leaves
+ * files out of what the others list.
+ *
+ * @param patterns - the patterns.
+ */
+export const patternsProblem = (patterns) => patterns.length > 0 && patterns.every(isNegated)
+    ? `every pattern is a \`!\` one (${patterns.map((pattern) => `"${pattern}"`).join(", ")}), which only leaves files out of what the others list: add a pattern that lists files beside them`
+    : undefined;
+/** The folder of a project's dependencies. */
+const DEPENDENCIES = "node_modules";
+/**
+ * What a pattern leaves out: the dependencies, unless it names them. A `**` from a monorepo's root would otherwise walk
+ * every package's, seconds on the server's thread for files nobody asked for, as Storybook's own globs skip them.
+ *
+ * @param pattern - the pattern.
+ */
+const excludedFrom = (pattern) => pattern.includes(DEPENDENCIES) ? () => false : (name) => name === DEPENDENCIES;
+/** The files a pattern matches on the disk, the dependencies left out unless it names them. */
+const globbed = (root, pattern) => globSync(pattern, { cwd: root, exclude: excludedFrom(pattern) });
+/**
+ * Whether a file is left out: a `!` pattern matched it, or one of the folders it is in (`!src/drafts`), as fast-glob
+ * leaves out a folder's every file.
+ *
+ * @param key - the file's key (`./src/drafts/x.stories.tsx`).
+ * @param left - the keys of the files and folders the `!` patterns matched.
+ */
+const isLeftOut = (key, left) => {
+    const segments = key.split("/");
+    return segments.some((_segment, at) => at > 0 && left.has(segments.slice(0, at + 1).join("/")));
+};
+/**
+ * A pattern without its trailing slashes (`src/drafts/`): the glob gives the folder it names without them. A loop,
+ * not a regular expression, whose backtracking a long run of slashes would make quadratic.
+ *
+ * @param pattern - the pattern.
+ */
+const withoutTrailingSlashes = (pattern) => {
+    let end = pattern.length;
+    while (end > 0 && pattern[end - 1] === "/")
+        end -= 1;
+    return pattern.slice(0, end);
+};
+/**
+ * The files a list of patterns lists, each once, sorted by key.
+ *
+ * @param root - the folder the patterns are relative to: the declaring module's.
+ * @param patterns - the patterns (`../src/**\/*.stories.tsx`, `!../src/**\/legacy/*`), in any order.
+ * @param find - what matches one pattern; the disk's by default, another system's in a test.
+ * @param paths - the path functions; the running system's unless a test names another.
+ * @throws when every pattern is a `!` one (`patternsProblem`).
+ */
+export const listedFiles = (root, patterns, find = globbed, paths = VITE_PATHS) => {
+    const problem = patternsProblem(patterns);
+    if (problem !== undefined)
+        throw new Error(problem);
+    // with forward slashes on every system, so a file has the same key wherever the catalogue runs
+    const keysOf = (pattern) => find(root, pattern).map((file) => paths.relativeKey(root, file));
+    const listing = patterns.filter((each) => !isNegated(each));
+    // a `!` pattern that names the dependencies leaves out only what a listing one names there: walked otherwise, it
+    // would read every package's folder for files no pattern lists
+    const isWalkedFor = (pattern) => !pattern.includes(DEPENDENCIES) || listing.some((each) => each.includes(DEPENDENCIES));
+    const left = new Set(patterns
+        .filter((each) => isNegated(each) && isWalkedFor(each))
+        .flatMap((pattern) => keysOf(withoutTrailingSlashes(pattern.slice(NEGATION.length)))));
+    const listed = new Map();
+    for (const pattern of listing)
+        for (const key of keysOf(pattern))
+            if (!isLeftOut(key, left) && !listed.has(key))
+                listed.set(key, pattern);
+    // by code unit, as a plain `sort()` orders the keys: the keys are unique
+    return [...listed]
+        .sort(([first], [second]) => (first < second ? -1 : 1))
+        .map(([key, pattern]) => ({ key, pattern }));
+};

package/dist/src/vite/textQueries.d.ts

@@ -1,5 +1,5 @@
 /**
- * The queries the plugin answers with a module made from a file's text: a story file's code, its component's page, a
+ * The queries the plugin answers with a module made from a file: a story file's docs and code, its component's page, a
  * source's Markdown, a docs page.
  *
  * @remarks
@@ -8,6 +8,8 @@
  *
  * @module
  */
+/** The query that asks for a story file's component docs. */
+export declare const DOCS_QUERY = "?forgebook-docs";
 /** The query that asks for a story file's code: each story's `render` as written. */
 export declare const CODE_QUERY = "?forgebook-code";
 /** The query that asks for a story file's component page: its documentation file as HTML. */
@@ -18,3 +20,7 @@ export declare const MARKDOWN_QUERY = "?forgebook-markdown";
 export declare const DOCS_PAGE_QUERY = "?forgebook-docs-page";
 /** The query that asks for the written home (`forgebook.home.md`), rendered: its file, then this. */
 export declare const HOME_QUERY = "?forgebook-home";
+/** The queries `textModules.ts` answers. */
+export declare const TEXT_QUERIES: readonly string[];
+/** The queries of a story file's modules the shell reads, which hand an edit to it in place on a dev server. */
+export declare const RENEWED_QUERIES: readonly string[];

package/dist/src/vite/textQueries.js

@@ -1,5 +1,5 @@
 /**
- * The queries the plugin answers with a module made from a file's text: a story file's code, its component's page, a
+ * The queries the plugin answers with a module made from a file: a story file's docs and code, its component's page, a
  * source's Markdown, a docs page.
  *
  * @remarks
@@ -8,6 +8,8 @@
  *
  * @module
  */
+/** The query that asks for a story file's component docs. */
+export const DOCS_QUERY = "?forgebook-docs";
 /** The query that asks for a story file's code: each story's `render` as written. */
 export const CODE_QUERY = "?forgebook-code";
 /** The query that asks for a story file's component page: its documentation file as HTML. */
@@ -18,3 +20,7 @@ export const MARKDOWN_QUERY = "?forgebook-markdown";
 export const DOCS_PAGE_QUERY = "?forgebook-docs-page";
 /** The query that asks for the written home (`forgebook.home.md`), rendered: its file, then this. */
 export const HOME_QUERY = "?forgebook-home";
+/** The queries `textModules.ts` answers. */
+export const TEXT_QUERIES = [CODE_QUERY, PAGE_QUERY, MARKDOWN_QUERY];
+/** The queries of a story file's modules the shell reads, which hand an edit to it in place on a dev server. */
+export const RENEWED_QUERIES = [DOCS_QUERY, CODE_QUERY, PAGE_QUERY];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgebook",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "See every component in every theme, contrast, language and width: CSF stories, one frame per story, and a props table from the components' types.",
   "keywords": [
     "react",
@@ -240,7 +240,7 @@
     "lightningcss": "1.33.0",
     "marked": "18.1.0",
     "typescript-6": "npm:typescript@6.0.3",
-    "@forgebook/story-format": "0.2.0"
+    "@forgebook/story-format": "0.2.1"
   },
   "peerDependencies": {
     "@testing-library/dom": "^10.4.0",