@forgebook/svelte 0.0.0-stage → 0.2.0

package/dist/src/storyNode.js

@@ -0,0 +1,66 @@
+import { snippetOfArg } from "./snippetArgs.js";
+/** Whether a value is a component: Svelte 5 compiles every component to a function. */
+const isComponent = (value) => typeof value === "function";
+/** Whether a value is an object of props. */
+const isProps = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * Props with each `#name` text as its snippet; a `#name` with nothing to show sets nothing.
+ *
+ * @param props - the props, as the args or a render give them.
+ * @param snippetOf - makes a text's snippet.
+ */
+const withSnippets = (props, snippetOf) => Object.fromEntries(Object.entries(props).flatMap(([name, value]) => {
+    const snippet = snippetOfArg(name);
+    if (snippet === undefined)
+        return [[name, value]];
+    if (value === undefined || value === null || value === false)
+        return [];
+    if (typeof value !== "string" && typeof value !== "number")
+        throw new Error(`${name} takes a text, which its snippet draws; pass a snippet as ${snippet}`);
+    return [[snippet, snippetOf(snippet, String(value))]];
+}));
+/**
+ * What a render or a decorator returned, as a node.
+ *
+ * @param result - the component, or the component with props.
+ * @param props - the props a bare component is drawn with.
+ * @param snippetOf - makes a text's snippet.
+ * @param who - what returned it, for the error.
+ * @throws when it is neither, which the frame shows in place of the story.
+ */
+const nodeOf = (result, props, snippetOf, who) => {
+    if (isComponent(result))
+        return { component: result, props: withSnippets(props, snippetOf) };
+    // `{ Component, props }`, as Storybook's Svelte stories write it
+    if (isProps(result) && isComponent(result["Component"])) {
+        const chosen = result["props"];
+        return { component: result["Component"], props: withSnippets(isProps(chosen) ? chosen : {}, snippetOf) };
+    }
+    throw new Error(`${who} returned neither a component nor { Component, props }`);
+};
+/**
+ * The story with these args: its render (or the meta's component), inside its decorators.
+ *
+ * @param loaded - the story.
+ * @param context - the args and the canvas its render, play and decorators read.
+ * @param outer - the catalogue's decorators, outside the story's and the meta's.
+ * @param snippetOf - makes the snippet of a `#name` text.
+ * @throws when the story has nothing to draw, or a render or a decorator returns what cannot be drawn.
+ */
+export const storyNode = (loaded, context, outer, snippetOf) => {
+    const { args } = context;
+    const story = () => {
+        if (loaded.render !== undefined)
+            return nodeOf(loaded.render(args, context), args, snippetOf, "A render");
+        if (loaded.component !== undefined)
+            return nodeOf(loaded.component, args, snippetOf, "The meta's component");
+        throw new Error("The story has neither a render nor a component to draw");
+    };
+    return [...loaded.decorators, ...outer].reduce((inner, decorator) => {
+        const result = decorator(() => inner, context);
+        // a decorator that only reads the context, or sets one, returns the story as it was given
+        if (result === inner)
+            return inner;
+        return { ...nodeOf(result, {}, snippetOf, "A decorator"), inner };
+    }, story());
+};

package/dist/src/storyView.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What the frame hands the components inside a story through Svelte's context: the shown language's texts and the story
+ * clock, read when they are read, so a template that reads them follows a change.
+ *
+ * @remarks
+ * The renderer's host sets it (`StoryHost.svelte`); `texts.ts` and `clock.ts` read it. Outside a catalogue there is
+ * none, and each reader says what it falls back to.
+ *
+ * @module
+ */
+import type { StoryClock } from "@forgebook/story-format/clock";
+import type { StoryTextTable } from "@forgebook/story-format/texts";
+/** What a story's components read of the frame, each value of the moment. */
+export type StoryView = {
+    /** The texts of the shown language. */
+    readonly texts: StoryTextTable;
+    /** The story's clock: replaced when the story starts over. */
+    readonly clock: StoryClock;
+};
+/** The context's key. */
+export declare const STORY_VIEW: unique symbol;
+/**
+ * The view the frame set, for a component inside a story; called while the component is initialised, as Svelte's
+ * context is.
+ *
+ * @returns the view, or none outside a catalogue.
+ */
+export declare const storyView: () => StoryView | undefined;

package/dist/src/storyView.js

@@ -0,0 +1,10 @@
+import { getContext, hasContext } from "svelte";
+/** The context's key. */
+export const STORY_VIEW = Symbol("forgebook story view");
+/**
+ * The view the frame set, for a component inside a story; called while the component is initialised, as Svelte's
+ * context is.
+ *
+ * @returns the view, or none outside a catalogue.
+ */
+export const storyView = () => hasContext(STORY_VIEW) ? getContext(STORY_VIEW) : undefined;

package/dist/src/svelteRenderer.d.ts

@@ -0,0 +1,19 @@
+import type { StoryRenderer } from "forgebook/renderer";
+import { type StoryNode } from "./storyNode.ts";
+/** What the host draws: the story's tree of the moment, and whether it failed. */
+export type StoryScene = {
+    /** The story's tree, made when it is read: what the story throws is thrown here, inside the host's boundary. */
+    readonly node: StoryNode;
+    /** Grows at each new try after an error, so the story is drawn anew. */
+    readonly attempt: number;
+    /** Whether the story threw, and is not drawn until it is tried again. */
+    readonly isFailed: boolean;
+    /**
+     * Called by the host's boundary with what the story threw.
+     *
+     * @param error - the error.
+     */
+    readonly fail: (error: unknown) => void;
+};
+/** Svelte as the frame draws with it. */
+export declare const svelteRenderer: StoryRenderer;

package/dist/src/svelteRenderer.js

@@ -0,0 +1,196 @@
+import { storyTextOf } from "@forgebook/story-format/texts";
+import { storyContextOf, untracedStep } from "forgebook/renderer";
+import { flushSync, mount, settled, unmount } from "svelte";
+import StoryHost from "./StoryHost.svelte";
+import { storyCell } from "./storyCell.js";
+import { storyNode } from "./storyNode.js";
+import { STORY_VIEW } from "./storyView.js";
+import { textSnippets } from "./textSnippet.js";
+/** An error as the frame takes it. */
+const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
+/**
+ * Whether two drawings draw the same story with the same decorators.
+ *
+ * @param current - the drawing on screen.
+ * @param next - the new one.
+ */
+const isSameStory = (current, next) => current.story === next.story &&
+    current.decorators.length === next.decorators.length &&
+    current.decorators.every((decorator, index) => decorator === next.decorators[index]);
+/**
+ * What a render and a decorator receive, reading the moment's values when they are read: a render follows what it read
+ * and nothing else.
+ *
+ * @param args - the args.
+ * @param view - the rest of what the story reads.
+ * @param scene - the drawing on screen.
+ * @param canvas - the story's canvas.
+ */
+const liveContext = (args, view, scene, canvas) => ({
+    get args() {
+        return args.current;
+    },
+    step: untracedStep,
+    canvasElement: canvas,
+    get text() {
+        return storyTextOf(view.texts.current);
+    },
+    get clock() {
+        return view.clock.current;
+    },
+    get globals() {
+        return view.globals.current;
+    },
+    get loaded() {
+        return view.loaded.current;
+    },
+    get id() {
+        return scene.current.identity.id;
+    },
+    get name() {
+        return scene.current.identity.name;
+    },
+    get title() {
+        return scene.current.identity.title;
+    },
+    get parameters() {
+        return scene.current.story.parameters;
+    }
+});
+/**
+ * The context the story's components read, as a map for Svelte's `mount` and `render`.
+ *
+ * @param view - the texts and the clock, read when read.
+ */
+const viewContext = (view) => new Map([[STORY_VIEW, view]]);
+/**
+ * Brings the view to a new drawing's values; the switches only when one changed, since they come as a new object.
+ *
+ * @param view - the view's values.
+ * @param next - the new drawing.
+ */
+const assignView = (view, next) => {
+    if (JSON.stringify(view.globals.current) !== JSON.stringify(next.globals))
+        view.globals.set(next.globals);
+    view.texts.set(next.texts);
+    view.clock.set(next.clock);
+    view.loaded.set(next.loaded);
+};
+/** Svelte as the frame draws with it. */
+export const svelteRenderer = {
+    mount: (canvas, first, onError) => {
+        const scene = storyCell(first);
+        const args = storyCell(first.args);
+        const view = {
+            texts: storyCell(first.texts),
+            clock: storyCell(first.clock),
+            globals: storyCell(first.globals),
+            loaded: storyCell(first.loaded)
+        };
+        const attempt = storyCell(0);
+        const failed = storyCell(false);
+        // the same as `failed`, read where nothing must follow it
+        let hasFailed = false;
+        // a new try after an error, not settled yet, and how many drawings came since it started: its error, which Svelte
+        // reports after drawing, may be of args no longer shown
+        let isTrying = false;
+        let updatesSinceTry = 0;
+        const context = liveContext(args, view, scene, canvas);
+        const snippetOf = textSnippets();
+        let markDrawn = () => undefined;
+        const drawn = new Promise((resolve) => {
+            markDrawn = resolve;
+        });
+        const host = {
+            get node() {
+                return storyNode(scene.current.story, context, scene.current.decorators, snippetOf);
+            },
+            get attempt() {
+                return attempt.current;
+            },
+            get isFailed() {
+                return failed.current;
+            },
+            fail: (error) => {
+                if (isTrying && updatesSinceTry > 0) {
+                    // the args changed while the try was drawn: tried again with them, the failed try said nothing of
+                    tryAgain();
+                    return;
+                }
+                if (!hasFailed)
+                    onError(toError(error));
+                hasFailed = true;
+                failed.set(true);
+            }
+        };
+        const instance = mount(StoryHost, {
+            target: canvas,
+            props: { scene: host },
+            context: viewContext({
+                get texts() {
+                    return view.texts.current;
+                },
+                get clock() {
+                    return view.clock.current;
+                }
+            })
+        });
+        // once Svelte has settled, unless the story threw: tried again after an error, a story drawn at last is drawn
+        const markDrawnOnceSettled = () => {
+            void settled().then(() => {
+                if (!hasFailed)
+                    markDrawn();
+            });
+        };
+        /** Draws the story anew with the args of the moment, after an error. */
+        const tryAgain = () => {
+            hasFailed = false;
+            failed.set(false);
+            attempt.set(attempt.current + 1);
+            const tried = attempt.current;
+            isTrying = true;
+            updatesSinceTry = 0;
+            void settled().then(() => {
+                if (attempt.current === tried)
+                    isTrying = false;
+            });
+            markDrawnOnceSettled();
+        };
+        // the effects run now, `onMount` among them: a story that throws there is not drawn
+        flushSync();
+        markDrawnOnceSettled();
+        return {
+            drawn,
+            update: (next) => {
+                args.set(next.args);
+                assignView(view, next);
+                if (!isSameStory(scene.current, next))
+                    scene.set(next);
+                updatesSinceTry += 1;
+                if (hasFailed)
+                    tryAgain();
+            },
+            unmount: () => {
+                void unmount(instance);
+            }
+        };
+    },
+    renderToString: async (drawing) => {
+        const { render } = await import("svelte/server");
+        const context = storyContextOf(drawing, drawing.args, () => document.body);
+        const snippetOf = textSnippets();
+        const scene = {
+            get node() {
+                return storyNode(drawing.story, context, drawing.decorators, snippetOf);
+            },
+            attempt: 0,
+            isFailed: false,
+            fail: () => undefined
+        };
+        const output = await render(StoryHost, {
+            props: { scene },
+            context: viewContext({ texts: drawing.texts, clock: drawing.clock })
+        });
+        return output.body;
+    }
+};

package/dist/src/textSnippet.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A snippet that draws a text: what a `#name` arg becomes, so a component's `{@render children()}` draws the text the
+ * story or the props panel wrote.
+ *
+ * @remarks
+ * A snippet made outside a component is a raw one, which Svelte draws from HTML and which must be one element: the text
+ * sits in a `span`. Each snippet prop keeps the snippet of its text, so a story drawn again with the same text keeps what it drew,
+ * and a text typed in the panel replaces the one before.
+ *
+ * @module
+ */
+import { type Snippet } from "svelte";
+/**
+ * Makes the snippet of a snippet prop's text, the same one while the text stays the same.
+ *
+ * @param prop - the snippet prop (`children`).
+ * @param text - its text.
+ */
+export type TextSnippets = (prop: string, text: string) => Snippet;
+/**
+ * The snippets of a story's texts, kept for as long as the story is drawn.
+ *
+ * @returns the function that makes a text's snippet.
+ */
+export declare const textSnippets: () => TextSnippets;

package/dist/src/textSnippet.js

@@ -0,0 +1,30 @@
+/**
+ * A snippet that draws a text: what a `#name` arg becomes, so a component's `{@render children()}` draws the text the
+ * story or the props panel wrote.
+ *
+ * @remarks
+ * A snippet made outside a component is a raw one, which Svelte draws from HTML and which must be one element: the text
+ * sits in a `span`. Each snippet prop keeps the snippet of its text, so a story drawn again with the same text keeps what it drew,
+ * and a text typed in the panel replaces the one before.
+ *
+ * @module
+ */
+import { createRawSnippet } from "svelte";
+/** A text as HTML holds it. */
+const escapedText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+/**
+ * The snippets of a story's texts, kept for as long as the story is drawn.
+ *
+ * @returns the function that makes a text's snippet.
+ */
+export const textSnippets = () => {
+    const kept = new Map();
+    return (prop, text) => {
+        const known = kept.get(prop);
+        if (known?.text === text)
+            return known.snippet;
+        const snippet = createRawSnippet(() => ({ render: () => `<span>${escapedText(text)}</span>` }));
+        kept.set(prop, { text, snippet });
+        return snippet;
+    };
+};

package/dist/src/texts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The texts inside the stories for Svelte components inside a story: the shown language's table, as the frame sets it,
+ * read with `getStoryText()`.
+ *
+ * @remarks
+ * The table and the text function are the format's (`@forgebook/story-format/texts`); this module is how a Svelte
+ * component reads them. The text function reads the language when it is called, so a template that calls it follows a
+ * change; outside a catalogue there is no table, and a text is its key in brackets.
+ *
+ * @module
+ */
+import { type StoryTextFunction } from "@forgebook/story-format/texts";
+/**
+ * The text function of the shown language, for a component inside a story; called while the component is initialised.
+ *
+ * @returns `text(key, values?)`, reading the language when called.
+ */
+export declare const getStoryText: () => StoryTextFunction;

package/dist/src/texts.js

@@ -0,0 +1,22 @@
+/**
+ * The texts inside the stories for Svelte components inside a story: the shown language's table, as the frame sets it,
+ * read with `getStoryText()`.
+ *
+ * @remarks
+ * The table and the text function are the format's (`@forgebook/story-format/texts`); this module is how a Svelte
+ * component reads them. The text function reads the language when it is called, so a template that calls it follows a
+ * change; outside a catalogue there is no table, and a text is its key in brackets.
+ *
+ * @module
+ */
+import { storyTextOf } from "@forgebook/story-format/texts";
+import { storyView } from "./storyView.js";
+/**
+ * The text function of the shown language, for a component inside a story; called while the component is initialised.
+ *
+ * @returns `text(key, values?)`, reading the language when called.
+ */
+export const getStoryText = () => {
+    const view = storyView();
+    return (...parameters) => storyTextOf(view?.texts ?? {})(...parameters);
+};

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

@@ -0,0 +1,23 @@
+import type { PropDocs } from "forgebook/component-docs";
+import ts from "typescript-6";
+/** What a component takes. */
+export type ComponentProps = {
+    /** Its props, a snippet as `#name`. */
+    readonly props: readonly PropDocs[];
+    /** Its parts: the keys of its `classNames`, `styles` and `refs` props. */
+    readonly parts: readonly string[];
+    /** The files its own props are declared in, a component as its `.svelte` file. */
+    readonly sources: readonly string[];
+};
+/** A file as the docs name it: a component's `.svelte` file rather than the TypeScript written for it. */
+export declare const sourceFileOf: (fileName: string) => string;
+/**
+ * What a component takes.
+ *
+ * @param componentSymbol - the component's declared symbol.
+ * @param checker - the program's checker.
+ * @param node - where the code names the component.
+ * @param componentFile - the component's file, for which props are its own.
+ * @throws when its type is not a component's.
+ */
+export declare const componentProps: (componentSymbol: ts.Symbol, checker: ts.TypeChecker, node: ts.Node, componentFile: string) => ComponentProps;

package/dist/src/vite/componentProps.js

@@ -0,0 +1,132 @@
+/**
+ * What a Svelte component takes, read from its type: its props, a snippet as the arg that fills it with a text
+ * (`#children`), a callback prop as an event (`onclick`, as Svelte 5 names them), each prop's default from its
+ * `$props()`.
+ *
+ * @remarks
+ * A component's type is `Component<Props>`, as `svelte2tsx` writes a `.svelte` file and as a package declares one, so its
+ * props are what it is called with. They read as a React component's do (`forgebook/vite/prop-docs`), from the checker's
+ * symbols; what it passes on to an element comes from `node_modules` (`svelte/elements`) and is left out. A default is
+ * what the component's `$props()` destructuring gives, `$bindable(value)` included, since the type does not hold it.
+ *
+ * @module
+ */
+import { dirname } from "node:path";
+import { declarationOrder, isForeign, partsOf, propDocs } from "forgebook/vite/prop-docs";
+import ts from "typescript-6";
+import { componentOfScriptFile } from "./svelteSources.js";
+/** A callback prop: `on` and a letter, as Svelte names an element's (`onclick`) and a component's own (`onRemove`). */
+const EVENT_NAME = /^on[A-Za-z]/;
+/** A file as the docs name it: a component's `.svelte` file rather than the TypeScript written for it. */
+export const sourceFileOf = (fileName) => componentOfScriptFile(fileName) ?? fileName;
+/**
+ * The type of a component's props: what its function is called with, or, for a component declared as a class, what its
+ * constructor's `props` take.
+ *
+ * @param type - the component's type.
+ * @param checker - the program's checker.
+ * @param node - where the code names it.
+ */
+const propsTypeOf = (type, checker, node) => {
+    const called = type.getCallSignatures().find((signature) => signature.parameters.length >= 2);
+    const props = called?.parameters[1];
+    if (props !== undefined)
+        return checker.getTypeOfSymbolAtLocation(props, node);
+    const options = type.getConstructSignatures()[0]?.parameters[0];
+    if (options === undefined)
+        return undefined;
+    const fromOptions = checker.getTypeOfSymbolAtLocation(options, node).getProperty("props");
+    return fromOptions === undefined ? undefined : checker.getTypeOfSymbolAtLocation(fromOptions, node);
+};
+/** Whether a type is Svelte's `Snippet`. */
+const isSnippet = (type) => {
+    const symbol = type.aliasSymbol ?? type.getSymbol();
+    return (symbol?.getName() === "Snippet" &&
+        (symbol.declarations ?? []).some((declaration) => /[\\/]svelte[\\/]types[\\/]/.test(declaration.getSourceFile().fileName)));
+};
+/** Whether a declaration is the component's `$props()` destructuring. */
+const isPropsDeclaration = (node, source) => ts.isVariableDeclaration(node) &&
+    ts.isObjectBindingPattern(node.name) &&
+    node.initializer !== undefined &&
+    ts.isCallExpression(node.initializer) &&
+    node.initializer.expression.getText(source) === "$props";
+/**
+ * What a prop's destructuring gives it when it is not passed: its initialiser, or what `$bindable(value)` holds.
+ *
+ * @param element - the prop's element of the destructuring.
+ * @param source - the file.
+ * @returns the default as the source writes it, or none.
+ */
+const defaultOf = (element, source) => {
+    const written = element.initializer;
+    if (element.dotDotDotToken !== undefined || written === undefined)
+        return undefined;
+    const isBindable = ts.isCallExpression(written) && written.expression.getText(source) === "$bindable";
+    const value = isBindable ? written.arguments[0] : written;
+    return value?.getText(source).replace(/\s+/g, " ");
+};
+/**
+ * The defaults a component's `$props()` gives, by prop: `let { tone = "neutral", value = $bindable("") } = $props()`.
+ *
+ * @param source - the file that declares the component.
+ */
+const propsDefaults = (source) => {
+    const find = (node) => isPropsDeclaration(node, source) ? node.name : ts.forEachChild(node, find);
+    const pattern = find(source);
+    return new Map((pattern?.elements ?? []).flatMap((element) => {
+        const value = defaultOf(element, source);
+        return value === undefined ? [] : [[(element.propertyName ?? element.name).getText(source), value]];
+    }));
+};
+/**
+ * One prop of a component: a snippet as the arg that fills it with a text, a callback prop as an event.
+ *
+ * @param symbol - the prop.
+ * @param checker - the program's checker.
+ * @param node - where the code names the component.
+ * @param defaults - the defaults its `$props()` gives.
+ */
+const sveltePropDocs = (symbol, checker, node, defaults) => {
+    const read = propDocs(symbol, checker, node, { eventName: EVENT_NAME });
+    // a component without TypeScript writes its props in JSDoc, whose `@property {T} name - text` keeps the dash
+    const docs = { ...read, description: read.description.replace(/^-\s+/, "") };
+    const type = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(symbol, node));
+    if (isSnippet(type)) {
+        // any text can fill it: the panel offers a field, and the renderer makes the snippet
+        return {
+            name: `#${docs.name}`,
+            kind: "other",
+            type: docs.type,
+            description: docs.description,
+            isRequired: false,
+            canTakeText: true
+        };
+    }
+    const defaultValue = docs.defaultValue ?? defaults.get(docs.name);
+    return { ...docs, ...(defaultValue === undefined ? {} : { defaultValue }) };
+};
+/**
+ * What a component takes.
+ *
+ * @param componentSymbol - the component's declared symbol.
+ * @param checker - the program's checker.
+ * @param node - where the code names the component.
+ * @param componentFile - the component's file, for which props are its own.
+ * @throws when its type is not a component's.
+ */
+export const componentProps = (componentSymbol, checker, node, componentFile) => {
+    const propsType = propsTypeOf(checker.getTypeOfSymbolAtLocation(componentSymbol, node), checker, node);
+    if (propsType === undefined)
+        throw new Error(`${componentSymbol.getName()} is not a Svelte component`);
+    const declaration = componentSymbol.declarations?.[0]?.getSourceFile();
+    const defaults = declaration === undefined ? new Map() : propsDefaults(declaration);
+    const symbols = declarationOrder(propsType.getProperties().filter((prop) => (prop.declarations ?? []).length === 0 || !isForeign(prop)), dirname(componentFile));
+    return {
+        props: symbols.map((symbol) => sveltePropDocs(symbol, checker, node, defaults)),
+        parts: partsOf(propsType, checker, node),
+        sources: [
+            componentFile,
+            ...symbols.flatMap((symbol) => (symbol.declarations ?? []).map((each) => sourceFileOf(each.getSourceFile().fileName)))
+        ]
+    };
+};

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

@@ -0,0 +1,37 @@
+import type { ComponentDocs, NoComponentDocs } from "forgebook/component-docs";
+import type { StoryComponentResult, StoryFileShape } from "forgebook/vite/adapter";
+/** The module a Svelte story file imports its types from (`Meta`, `Story`), for the stories `forgebook new` writes. */
+export declare const storyTypesModule = "@forgebook/svelte";
+/**
+ * A story file's component with the file that declares it.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component, `{ docs: { name: null } }` when the meta names none, or a message saying why the file
+ * cannot be read.
+ */
+export declare const extractStoryComponent: (storyFile: string) => StoryComponentResult;
+/**
+ * The docs of a story file's component.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component's docs, `{ name: null }` when the meta names no component, or a message saying why the file
+ * cannot be read.
+ */
+export declare const extractComponentDocs: (storyFile: string) => ComponentDocs | NoComponentDocs | string;
+/**
+ * A component a file exports, for writing its first stories (`forgebook new`): a `.svelte` file is its default export,
+ * named after its file.
+ *
+ * @param file - the component's file, absolute.
+ * @param exportName - the export to read; the file's only component when none.
+ * @returns the component, or a message saying why it cannot be read (no component, several, a name not exported).
+ */
+export declare const extractFileComponent: (file: string, exportName?: string) => StoryComponentResult;
+/**
+ * How `forgebook new` writes a Svelte component's stories: `.ts`, since a story needs no markup, a `.svelte` file
+ * imported by its default export and with its extension.
+ *
+ * @param name - the component's name.
+ * @param file - the component's file, absolute.
+ */
+export declare const storyFileShape: (name: string, file: string) => StoryFileShape;