forgebook 0.3.3 → 0.4.1

package/dist/src/storyControls.js

@@ -0,0 +1,100 @@
+import { checkedAddressArgs, declaredArgProps } from "./addressArgs.js";
+import { readArgsParam } from "./addressArgsParam.js";
+import { addressArgsFor } from "./addressTexts.js";
+import { isColorProp, isNamedProp } from "./argTypes.js";
+import { panelArgsParam } from "./messages.js";
+import { holdsUnsafePart, isFileList, isValueOfShape, resolvedShape } from "./shapeValues.js";
+import { schemaProblem } from "./valueSchema.js";
+import { canSetShape } from "./valueShape.js";
+/** A prop's control when no `argTypes` names one: from its kind. */
+const controlOfKind = (prop, namedValues) => {
+    if (isNamedProp(prop, namedValues))
+        return "named";
+    if (prop.shape !== undefined)
+        return "object";
+    if (prop.kind === "choice")
+        return "select";
+    if (prop.kind === "number")
+        return "number";
+    if (prop.kind === "toggle")
+        return "boolean";
+    return isColorProp(prop) ? "color" : "text";
+};
+/**
+ * One settable prop as an agent reads it.
+ *
+ * @param prop - the prop.
+ * @param namedValues - the source's named values.
+ * @param customSchemas - the custom controls' schemas.
+ */
+const storyControl = (prop, namedValues, customSchemas) => {
+    const custom = prop.customControl;
+    const schema = custom !== undefined && Object.hasOwn(customSchemas, custom) ? customSchemas[custom] : undefined;
+    const own = prop.control === undefined || prop.control === "none" ? controlOfKind(prop, namedValues) : prop.control;
+    const control = custom === undefined ? own : "custom";
+    return {
+        name: prop.name,
+        control,
+        type: prop.type,
+        isRequired: prop.isRequired,
+        ...(prop.shape === undefined ? {} : { shape: resolvedShape(prop.shape) }),
+        ...(prop.choices === undefined ? {} : { choices: prop.choices }),
+        ...(prop.min === undefined ? {} : { min: prop.min }),
+        ...(prop.max === undefined ? {} : { max: prop.max }),
+        ...(control === "named" ? { named: Object.keys(namedValues[prop.type] ?? {}) } : {}),
+        ...(prop.tokens === undefined ? {} : { tokens: prop.tokens }),
+        ...(custom === undefined ? {} : { custom }),
+        ...(prop.settings === undefined ? {} : { settings: prop.settings }),
+        ...(schema === undefined ? {} : { schema })
+    };
+};
+/**
+ * The props a story's values can set.
+ *
+ * @param declaration - what the story declares.
+ */
+export const storyControlsOf = (declaration) => {
+    const argDeclaration = declaration;
+    const canSet = (prop) => prop.shape === undefined || canSetShape(prop.shape, declaration.namedValues);
+    return declaredArgProps(argDeclaration)
+        .filter(canSet)
+        .map((prop) => storyControl(prop, declaration.namedValues, declaration.customSchemas ?? {}));
+};
+/**
+ * The values an agent asks to set, checked as a link's are.
+ *
+ * @param text - the values, as JSON.
+ * @param declaration - what the story declares.
+ * @param addressTexts - how the framework's stories take a link's texts; `any` by default.
+ */
+export const checkedSetArgs = (text, declaration, addressTexts = "any") => {
+    const { args, link } = readArgsParam(text.trimStart().startsWith("{") ? text : "{");
+    const unread = (link?.unread ?? []).map((name) => ({ name, reason: "unreadable" }));
+    const plain = addressArgsFor(args, addressTexts);
+    const notPlain = Object.keys(args)
+        .filter((name) => !Object.hasOwn(plain, name))
+        .map((name) => ({ name, reason: "markup" }));
+    const { accepted, dropped } = checkedAddressArgs(plain, declaration, undefined, {
+        isFileList,
+        isValueOfShape,
+        custom: Object.fromEntries(Object.entries(declaration.customSchemas ?? {}).map(([name, schema]) => [
+            name,
+            (value) => holdsUnsafePart(value, true) ? "not what a link may give" : schemaProblem(schema, value)
+        ]))
+    });
+    return { accepted, dropped: [...unread, ...notPlain, ...dropped], param: panelArgsParam(accepted) };
+};
+/**
+ * What is wrong with the custom controls a story names: one no configuration registers, or whose module did not load.
+ *
+ * @param controls - the story's controls.
+ * @param read - the custom controls as the server read them.
+ */
+export const customControlProblems = (controls, read) => controls.flatMap(({ custom, schema }) => {
+    if (custom === undefined || schema !== undefined)
+        return [];
+    const problem = read !== undefined && Object.hasOwn(read.problems, custom) ? read.problems[custom] : undefined;
+    return [
+        `The control "${custom}": ${problem ?? "no control is registered under this name in argControls"}`
+    ];
+});

package/dist/src/storyStatuses.d.ts

@@ -0,0 +1,55 @@
+/** How a status reads at a glance: the colour of its badge, each with its text contrast in both appearances. */
+export declare const STATUS_TONES: readonly ["neutral", "info", "positive", "caution", "critical"];
+/** One of the tones. */
+export type StatusTone = (typeof STATUS_TONES)[number];
+/** A status as a catalogue declares it (`statuses: { review: { label: "In review", tone: "caution" } }`). */
+export type StatusSetting = {
+    /** Its badge's text; the shell's own word for a default status (`strings` replaces it), else its tag. */
+    readonly label?: string;
+    /** Its badge's colour; `neutral` for a status of the catalogue's own. */
+    readonly tone?: StatusTone;
+};
+/** The statuses a configuration declares, by tag: `false` turns a default one off. */
+export type StatusSettings = Readonly<Record<string, StatusSetting | false>>;
+/** A status the catalogue has, its defaults filled in. */
+export type CatalogueStatus = {
+    /** Its tag (`review`). */
+    readonly id: string;
+    /** Its badge's text, when the catalogue writes one. */
+    readonly label?: string;
+    /** Its badge's colour. */
+    readonly tone: StatusTone;
+};
+/** The status whose tag says a component is not to be used any more, as TSDoc's `@deprecated` says it. */
+export declare const DEPRECATED_STATUS = "deprecated";
+/** The statuses every catalogue has unless it turns them off, in the order their badges come. */
+export declare const DEFAULT_STATUSES: Readonly<Record<string, StatusSetting>>;
+/**
+ * A catalogue's statuses: the defaults, each with what the configuration writes of it, then the configuration's own,
+ * less those it turns off.
+ *
+ * @param settings - what the configuration declares; none for the defaults.
+ */
+export declare const catalogueStatuses: (settings?: StatusSettings) => readonly CatalogueStatus[];
+/**
+ * Statuses declared in several places (the presets', then the catalogue's) as one declaration: status by status and
+ * field by field, so a catalogue renames a preset's status and keeps its tone; none when none declares any.
+ *
+ * @param all - the declarations, in order.
+ */
+export declare const mergedStatuses: (all: readonly (StatusSettings | undefined)[]) => {
+    readonly statuses?: StatusSettings;
+};
+/**
+ * The statuses a list of tags holds, in the catalogue's order.
+ *
+ * @param tags - a meta's or a story's tags.
+ * @param statuses - the catalogue's statuses.
+ */
+export declare const statusesOf: (tags: readonly string[], statuses: readonly CatalogueStatus[]) => readonly CatalogueStatus[];
+/**
+ * Why a configuration's statuses cannot be used, or none: they are written by JavaScript too, which no type stops.
+ *
+ * @param settings - the value written.
+ */
+export declare const statusesProblem: (settings: unknown) => string | undefined;

package/dist/src/storyStatuses.js

@@ -0,0 +1,104 @@
+/**
+ * A component's or a story's status (waiting for review, experimental, deprecated): a tag the catalogue declares as a
+ * status, read by the agents' answers on Node and by the shell's badges, which load only for a catalogue whose stories
+ * have tags.
+ *
+ * @remarks
+ * A status is a tag, so it is written where CSF writes one (the preview, a meta, a story; `!name` takes it away) and
+ * filtered by the tag filter; the declaration only says which tags are statuses and how they look. A meta's tags give
+ * the component's status, a story's the story's. Three are declared by default, each a catalogue may restyle, rename
+ * or turn off with `false`. Pure.
+ *
+ * @module
+ */
+import { TOOL_TAGS } from "./storyTagNames.js";
+/** How a status reads at a glance: the colour of its badge, each with its text contrast in both appearances. */
+export const STATUS_TONES = ["neutral", "info", "positive", "caution", "critical"];
+/** The status whose tag says a component is not to be used any more, as TSDoc's `@deprecated` says it. */
+export const DEPRECATED_STATUS = "deprecated";
+/** The statuses every catalogue has unless it turns them off, in the order their badges come. */
+export const DEFAULT_STATUSES = {
+    review: { tone: "caution" },
+    experimental: { tone: "info" },
+    [DEPRECATED_STATUS]: { tone: "critical" }
+};
+/**
+ * A catalogue's statuses: the defaults, each with what the configuration writes of it, then the configuration's own,
+ * less those it turns off.
+ *
+ * @param settings - what the configuration declares; none for the defaults.
+ */
+export const catalogueStatuses = (settings = {}) => Object.entries({ ...DEFAULT_STATUSES, ...settings }).flatMap(([id, setting]) => {
+    if (setting === false)
+        return [];
+    const { label, tone } = { ...DEFAULT_STATUSES[id], ...setting };
+    return [{ id, tone: tone ?? "neutral", ...(label === undefined ? {} : { label }) }];
+});
+/**
+ * Statuses declared in several places (the presets', then the catalogue's) as one declaration: status by status and
+ * field by field, so a catalogue renames a preset's status and keeps its tone; none when none declares any.
+ *
+ * @param all - the declarations, in order.
+ */
+export const mergedStatuses = (all) => {
+    const statuses = {};
+    for (const [id, status] of all.flatMap((each) => Object.entries(each ?? {}))) {
+        const before = statuses[id];
+        statuses[id] = status === false ? false : { ...(before === false ? {} : before), ...status };
+    }
+    return Object.keys(statuses).length === 0 ? {} : { statuses };
+};
+/**
+ * The statuses a list of tags holds, in the catalogue's order.
+ *
+ * @param tags - a meta's or a story's tags.
+ * @param statuses - the catalogue's statuses.
+ */
+export const statusesOf = (tags, statuses) => statuses.filter((status) => tags.includes(status.id));
+/**
+ * Why a status's fields cannot be used, or none: only `label` and `tone`, so a misspelt one is named, not ignored.
+ *
+ * @param id - its tag.
+ * @param setting - what is written for it.
+ */
+const fieldsProblem = (id, setting) => {
+    const unknown = Object.keys(setting).find((key) => key !== "label" && key !== "tone");
+    if (unknown !== undefined)
+        return `the status "${id}" has no field "${unknown}": it takes label and tone`;
+    const label = "label" in setting ? setting.label : undefined;
+    const tone = "tone" in setting ? setting.tone : undefined;
+    if (label !== undefined && (typeof label !== "string" || label === ""))
+        return `the status "${id}" has a label that is no text`;
+    if (tone !== undefined && !STATUS_TONES.some((each) => each === tone))
+        return `the status "${id}" has the tone ${JSON.stringify(tone)}: write one of ${STATUS_TONES.join(", ")}`;
+    return undefined;
+};
+/**
+ * Why one status a configuration declares cannot be used, or none.
+ *
+ * @param id - its tag.
+ * @param setting - what is written for it.
+ */
+const statusProblem = (id, setting) => {
+    if (id === "" || id.startsWith("!") || TOOL_TAGS.has(id))
+        return `"${id}" cannot be a status: a status is a tag of your own, not empty, no !name and none of ${[...TOOL_TAGS].join(", ")}`;
+    if (setting === false)
+        return undefined;
+    if (typeof setting !== "object" || setting === null || Array.isArray(setting))
+        return `the status "${id}" must be { label, tone } or false`;
+    return fieldsProblem(id, setting);
+};
+/**
+ * Why a configuration's statuses cannot be used, or none: they are written by JavaScript too, which no type stops.
+ *
+ * @param settings - the value written.
+ */
+export const statusesProblem = (settings) => {
+    if (settings === undefined)
+        return undefined;
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings))
+        return "statuses must be an object of statuses by tag: { review: { label, tone } }";
+    return Object.entries(settings)
+        .map(([id, setting]) => statusProblem(id, setting))
+        .find((problem) => problem !== undefined);
+};

package/dist/src/storyTagNames.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which of a story's tags a person filters by, apart from the filter itself (`storyTags.ts`).
+ *
+ * @remarks
+ * Apart because the sidebar asks it on every catalogue's first load, to know whether to offer a filter at all, and a
+ * catalogue with no tags must not pay for the rest; a component's page asks it too, to know whether to draw statuses.
+ * Pure.
+ *
+ * @module
+ */
+import { type StoryTree } from "./storyTree.ts";
+/** The tags CSF gives a meaning of its own: they say what a tool does with a story, not what the story is. */
+export declare const TOOL_TAGS: ReadonlySet<string>;
+/**
+ * Whether a person can filter by a tag: any but a tool's tag, and a `!name`, which only takes a tag away.
+ *
+ * @param tag - the tag, as a story holds it.
+ */
+export declare const isFilterTag: (tag: string) => boolean;
+/**
+ * Whether any listed story holds a tag a person can filter by: what offers the filter and draws the statuses' badges.
+ *
+ * @param tree - the tree.
+ */
+export declare const hasFilterTags: (tree: StoryTree) => boolean;

package/dist/src/storyTagNames.js

@@ -0,0 +1,25 @@
+/**
+ * Which of a story's tags a person filters by, apart from the filter itself (`storyTags.ts`).
+ *
+ * @remarks
+ * Apart because the sidebar asks it on every catalogue's first load, to know whether to offer a filter at all, and a
+ * catalogue with no tags must not pay for the rest; a component's page asks it too, to know whether to draw statuses.
+ * Pure.
+ *
+ * @module
+ */
+import { storyLocations } from "./storyTree.js";
+/** The tags CSF gives a meaning of its own: they say what a tool does with a story, not what the story is. */
+export const TOOL_TAGS = new Set(["dev", "test", "autodocs", "play-fn", "test-fn"]);
+/**
+ * Whether a person can filter by a tag: any but a tool's tag, and a `!name`, which only takes a tag away.
+ *
+ * @param tag - the tag, as a story holds it.
+ */
+export const isFilterTag = (tag) => !tag.startsWith("!") && !TOOL_TAGS.has(tag);
+/**
+ * Whether any listed story holds a tag a person can filter by: what offers the filter and draws the statuses' badges.
+ *
+ * @param tree - the tree.
+ */
+export const hasFilterTags = (tree) => storyLocations(tree).some(({ story }) => story.tags.some(isFilterTag));

package/dist/src/storyTags.d.ts

@@ -0,0 +1,29 @@
+import type { StoryTree } from "./storyTree.ts";
+/** One tag the catalogue's stories hold. */
+export type CatalogueTag = {
+    /** The tag. */
+    readonly tag: string;
+    /** How many listed stories hold it. */
+    readonly stories: number;
+};
+/**
+ * Whether a story's tags pass a filter.
+ *
+ * @param tags - the story's tags.
+ * @param filter - the filter's tags, each `name` or `!name`; none keeps every story.
+ */
+export declare const passesTags: (tags: readonly string[], filter: readonly string[]) => boolean;
+/**
+ * The tags a person can filter a catalogue by, by name, with the listed stories each one holds.
+ *
+ * @param tree - the tree.
+ */
+export declare const catalogueTags: (tree: StoryTree) => readonly CatalogueTag[];
+/**
+ * The tree the sidebar lists under a filter: only the stories that pass, and what holds them. Pages keep opening from
+ * the whole tree: an address still shows a story the filter leaves out.
+ *
+ * @param tree - the whole tree.
+ * @param filter - the filter's tags, each `name` or `!name`; none gives the tree as it is.
+ */
+export declare const taggedTree: (tree: StoryTree, filter: readonly string[]) => StoryTree;

package/dist/src/storyTags.js

@@ -0,0 +1,85 @@
+/**
+ * The tag filter: which stories a list of tags keeps, for the sidebar's tree and the agents' documents alike.
+ *
+ * @remarks
+ * Written as CSF writes a tag: `beta` asks for it, `!beta` asks to leave it out. A story stays when it holds any tag
+ * asked for and none left out, as Storybook's filter reads its choices, so ticking one more tag widens the list. A docs
+ * page holds no tags, so it reads as a story with none. Pure.
+ *
+ * @module
+ */
+import { isFilterTag } from "./storyTagNames.js";
+/**
+ * Whether a story's tags pass a filter.
+ *
+ * @param tags - the story's tags.
+ * @param filter - the filter's tags, each `name` or `!name`; none keeps every story.
+ */
+export const passesTags = (tags, filter) => {
+    const asked = filter.filter((tag) => !tag.startsWith("!"));
+    return (filter.every((tag) => !tag.startsWith("!") || !tags.includes(tag.slice(1))) &&
+        (asked.length === 0 || asked.some((tag) => tags.includes(tag))));
+};
+/** Every component of a source, whatever group it sits in. */
+const componentsOf = (source) => source.families.flatMap((family) => family.groups.flatMap((group) => group.components));
+/**
+ * The tags a person can filter a catalogue by, by name, with the listed stories each one holds.
+ *
+ * @param tree - the tree.
+ */
+export const catalogueTags = (tree) => {
+    const counts = new Map();
+    const stories = tree.sources.flatMap((source) => componentsOf(source).flatMap((component) => component.stories));
+    for (const tag of stories.flatMap((story) => story.tags.filter(isFilterTag))) {
+        counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    }
+    return [...counts]
+        .map(([tag, count]) => ({ tag, stories: count }))
+        .sort((one, other) => one.tag.localeCompare(other.tag));
+};
+/**
+ * A group with what the filter keeps: its components with only the stories that pass, and the aliases of the components
+ * that stay; an alias is opened to its component's page, so it follows that component.
+ *
+ * @param group - the group.
+ * @param filter - the filter's tags.
+ * @param keptTitles - the titles of the source's components that stay.
+ */
+const groupOf = (group, filter, keptTitles) => ({
+    ...group,
+    components: group.components.flatMap((component) => {
+        const stories = component.stories.filter((story) => passesTags(story.tags, filter));
+        return stories.length === 0 ? [] : [{ ...component, stories }];
+    }),
+    aliases: group.aliases.filter((alias) => keptTitles.has(alias.title))
+});
+/**
+ * The tree the sidebar lists under a filter: only the stories that pass, and what holds them. Pages keep opening from
+ * the whole tree: an address still shows a story the filter leaves out.
+ *
+ * @param tree - the whole tree.
+ * @param filter - the filter's tags, each `name` or `!name`; none gives the tree as it is.
+ */
+export const taggedTree = (tree, filter) => {
+    if (filter.length === 0)
+        return tree;
+    const hasAsked = filter.some((tag) => !tag.startsWith("!"));
+    return {
+        ...tree,
+        sources: tree.sources.map((source) => {
+            const keptTitles = new Set(componentsOf(source)
+                .filter((component) => component.stories.some((story) => passesTags(story.tags, filter)))
+                .map((component) => component.title));
+            return {
+                ...source,
+                pages: hasAsked ? [] : source.pages,
+                families: source.families.flatMap((family) => {
+                    const groups = family.groups
+                        .map((group) => groupOf(group, filter, keptTitles))
+                        .filter((group) => group.components.length > 0 || group.aliases.length > 0);
+                    return groups.length === 0 ? [] : [{ ...family, groups }];
+                })
+            };
+        })
+    };
+};

package/dist/src/storyTree.d.ts

@@ -97,6 +97,11 @@ export type TreeComponent = {
      * none, for the catalogue's.
      */
     readonly requiredFirst: RequiredFirst | undefined;
+    /**
+     * Its first file's meta's tags, the previews' under them: what is said of the component as a whole, its status
+     * among them (`storyStatuses.ts`), whatever a story adds or takes away. Empty when none.
+     */
+    readonly tags: readonly string[];
 };
 /** A group's entry for a component that lives elsewhere and is listed here too (the meta's `alsoIn`). */
 export type TreeAlias = {
@@ -239,6 +244,14 @@ export declare const testedStoryLocations: (tree: StoryTree) => StoryLocation[];
  * @returns its place, or `undefined` when no story has this id.
  */
 export declare const findStory: (tree: StoryTree, id: string) => StoryLocation | undefined;
+/**
+ * The story an address names: its `story`, or the one of a link written for Storybook. Either is only a name: it opens
+ * a page by `findStory`, or says that no such story is there.
+ *
+ * @param params - the address's query.
+ * @returns the story's id; none when the address names none.
+ */
+export declare const storyOfAddress: (params: URLSearchParams) => string | null;
 /** Where a component sits: its source, family and group. */
 export type ComponentLocation = Omit<StoryLocation, "story">;
 /**

package/dist/src/storyTree.js

@@ -126,7 +126,8 @@ const startedComponent = (source, file, entry, titlesById) => {
 const placedComponents = (source, problems) => {
     const byTitle = new Map();
     const titlesById = new Map();
-    const index = sourceFiles(source).index;
+    const { index, problems: unread = [] } = sourceFiles(source);
+    problems.push(...unread);
     // sorted, so a component's files, and so its stories, its docs and a clash's winner, never depend on the groups' order
     for (const file of Object.keys(index).sort()) {
         const entry = index[file];
@@ -249,7 +250,8 @@ const sourceFamilies = (source, problems) => {
             design: componentDesign(component),
             // its first file's, as its docs are
             propGroups: component.files[0]?.entry.propGroups ?? [],
-            requiredFirst: component.files[0]?.entry.requiredFirst
+            requiredFirst: component.files[0]?.entry.requiredFirst,
+            tags: component.files[0]?.entry.tags ?? []
         });
     }
     placeAliases(source, placed, families, problems);
@@ -299,7 +301,13 @@ export const storyTree = (sources) => {
     const shown = tree.filter((source) => source.families.length > 0 || source.pages.length > 0);
     return {
         sources: shown,
-        problems: [...problems, ...pageProblems(shown, new Set(storyIds(shown)), new Set(componentIds(shown)))]
+        // a script that does not parse is named by every group a dev server serves: once is enough
+        problems: [
+            ...new Set([
+                ...problems,
+                ...pageProblems(shown, new Set(storyIds(shown)), new Set(componentIds(shown)))
+            ])
+        ]
     };
 };
 /**
@@ -341,8 +349,20 @@ export const testedStoryLocations = (tree) => storyLocations(tree).filter((locat
 export const findStory = (tree, id) => {
     const locations = storyLocations(tree);
     return (locations.find((location) => location.story.id === id) ??
-        locations.find(({ source, component, story }) => formerStoryId(source.id, component.title, story.exportName) === id));
+        locations.find(({ source, component, story }) => formerStoryId(source.id, component.title, story.exportName) === id) ??
+        // a Storybook link names no source: the first in the catalogue's order that has a story of that id
+        locations.find(({ source, story }) => story.id === `${source.id}:${id}`));
 };
+/** Storybook's address of a story: `?path=/story/<id>`. */
+const STORYBOOK_STORY_PATH = /^\/story\/([^/]+)$/;
+/**
+ * The story an address names: its `story`, or the one of a link written for Storybook. Either is only a name: it opens
+ * a page by `findStory`, or says that no such story is there.
+ *
+ * @param params - the address's query.
+ * @returns the story's id; none when the address names none.
+ */
+export const storyOfAddress = (params) => params.get("story") ?? STORYBOOK_STORY_PATH.exec(params.get("path") ?? "")?.[1] ?? null;
 /**
  * Every component of the tree with its place.
  *

package/dist/src/storybookArgs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Storybook's form of an address's `args`, read as Storybook's `parseArgsParam` reads it, and its values typed for the
+ * props that receive them. Loaded only for a link in that form (`addressArgsParam.ts`). Pure.
+ *
+ * @remarks
+ * `name:value` pairs split by `;`, a list as `tags[0]:a;tags[1]:b`, `tags[]:a;tags[]:b` or `tags:a;tags:b`, and the marked
+ * values `!true`, `!false`, `!null`, `!hex(ff0000)`, `!rgba(1,2,3,0.5)`, `!hsl(…)`, `!date(…)`. Its unmarked values are
+ * only text, whatever they look like: whether `5` is a number and `007` a text depends on the prop, which the story
+ * declares later, so they stay text here and the check types them, keeping what Storybook's own reading loses (its `007`
+ * becomes `7`). Storybook leaves out any text outside a few characters as unsafe; here every value meets the same check as
+ * a JSON one (`addressArgs.ts`), so non-ASCII text is read.
+ *
+ * What cannot be held is named as unread: an object (`style.color:red`), a list with a hole (`tags[1]:b`, which patches a
+ * list the story owns), `!undefined`, a date that is none.
+ *
+ * @module
+ */
+import type { ArgsParamRead } from "./addressArgsParam.ts";
+/**
+ * Storybook's form, read.
+ *
+ * @param param - the parameter.
+ */
+export declare const readStorybookArgs: (param: string) => ArgsParamRead;