@forgebook/svelte 0.0.0-stage → 0.2.0

package/dist/src/vite/extractDocs.js

@@ -0,0 +1,249 @@
+/**
+ * The component of a Svelte story file, read from its types and comments: its props, snippets and callback props. The
+ * docs module of `@forgebook/svelte`: the plugin's worker and `forgebook-docs` load it through the adapter
+ * (`forgebook/vite/adapter`).
+ *
+ * @remarks
+ * The component is the meta's `component`, found by the type checker, so an import through an alias, a package or a
+ * barrel leads to its file. The checker reads a `.svelte` file as the TypeScript `svelte2tsx` writes for it
+ * (`svelteSources.ts`), in the core's programs, so what it takes is read as any component's (`componentProps.ts`). A
+ * component describes itself as Svelte's language server reads it, in its `<!-- @component -->` comment, tags included
+ * (`@useWhen`, `@deprecated`); the comment that opens its script, with `@module`, is the summary.
+ *
+ * @module
+ */
+import { basename, extname } from "node:path";
+import { chosenExport, programFor, summaryOf } from "forgebook/vite/docs-program";
+import { moduleSummaryOf } from "forgebook/vite/module-summary";
+import { declaredSymbol } from "forgebook/vite/prop-docs";
+import { signatureDocs } from "forgebook/vite/signature-docs";
+import { metaComponent, metaSubcomponents } from "forgebook/vite/story-meta";
+import { guidanceOf } from "forgebook/vite/usage-guidance";
+import ts from "typescript-6";
+import { componentProps, sourceFileOf } from "./componentProps.js";
+import { scriptOf } from "./svelteScript.js";
+import { COMPONENT_EXTENSION, componentScriptFile, SVELTE_SOURCES } from "./svelteSources.js";
+/** The module a Svelte story file imports its types from (`Meta`, `Story`), for the stories `forgebook new` writes. */
+export const storyTypesModule = "@forgebook/svelte";
+/** A story file's or a component's program, with its components read as TypeScript. */
+const svelteProgram = (file) => programFor(file, { sources: SVELTE_SOURCES });
+/**
+ * The file that declares a symbol, a component as its `.svelte` file.
+ *
+ * @param symbol - the declared symbol.
+ * @param fallback - the file when it has no declaration.
+ */
+const fileOf = (symbol, fallback) => sourceFileOf(symbol.declarations?.[0]?.getSourceFile().fileName ?? fallback);
+/**
+ * What a component says of itself: its `@component` comment, its tags, and its script's `@module` comment.
+ *
+ * @param symbol - its declared symbol.
+ * @param file - its file.
+ * @param program - the program.
+ */
+const componentProse = (symbol, file, program) => {
+    const isComponentFile = extname(file) === COMPONENT_EXTENSION;
+    const source = isComponentFile
+        ? ts.createSourceFile(file, scriptOf(ts.sys.readFile(file) ?? ""), ts.ScriptTarget.Latest, true)
+        : program.program.getSourceFile(file);
+    return {
+        description: summaryOf(symbol, program.checker),
+        summary: source === undefined ? "" : moduleSummaryOf(source.text),
+        ...guidanceOf(symbol, program.checker)
+    };
+};
+/**
+ * A component's docs and the files they come from.
+ *
+ * @param name - its name.
+ * @param symbol - its declared symbol.
+ * @param node - where the code names it.
+ * @param program - the program.
+ * @param subcomponents - the subcomponents' docs and files; none outside a story file.
+ */
+const componentOf = (name, symbol, node, program, subcomponents) => {
+    const file = fileOf(symbol, node.getSourceFile().fileName);
+    const read = componentProps(symbol, program.checker, node, file);
+    return {
+        docs: {
+            name,
+            ...componentProse(symbol, file, program),
+            props: read.props,
+            parts: read.parts,
+            subcomponents: subcomponents.docs
+        },
+        file,
+        sources: [...new Set([...read.sources, ...subcomponents.sources])]
+    };
+};
+/**
+ * Whether a symbol stands for a function rather than a component: a name in camelCase that can be called, declared
+ * outside a component's file. A Svelte component is a function too, so its name and its file tell.
+ */
+const isLogic = (symbol, checker, node) => /^[a-z]/.test(symbol.getName()) &&
+    symbol.getName() !== "default" &&
+    extname(fileOf(symbol, "")) !== COMPONENT_EXTENSION &&
+    checker.getTypeOfSymbolAtLocation(symbol, node).getCallSignatures().length > 0;
+/**
+ * A function's docs: its signature, which a story about logic shows first.
+ *
+ * @param symbol - the function's symbol.
+ * @param expression - where the code names it.
+ * @param program - the program.
+ */
+const logicOf = (symbol, expression, program) => {
+    const file = fileOf(symbol, expression.getSourceFile().fileName);
+    const signature = signatureDocs(symbol, expression, program.checker);
+    return {
+        docs: {
+            name: symbol.getName(),
+            ...componentProse(symbol, file, program),
+            props: [],
+            parts: [],
+            subcomponents: [],
+            ...(signature === undefined ? {} : { signature })
+        },
+        file,
+        sources: [file]
+    };
+};
+/**
+ * The docs of the subcomponents a story file's meta names, with the files they come from.
+ *
+ * @param source - the story file, parsed.
+ * @param program - its program.
+ * @returns the docs and their files, or a message naming the subcomponent that cannot be resolved.
+ */
+const subcomponentsOf = (source, program) => {
+    const docs = [];
+    const sources = [];
+    for (const subcomponent of metaSubcomponents(source, program.checker)) {
+        const symbol = declaredSymbol(subcomponent.symbol, program.checker);
+        if (symbol === undefined) {
+            return `${source.fileName}: the meta's subcomponent ${subcomponent.name} cannot be resolved`;
+        }
+        const file = fileOf(symbol, source.fileName);
+        const read = componentProps(symbol, program.checker, subcomponent.expression, file);
+        docs.push({
+            name: subcomponent.name,
+            description: componentProse(symbol, file, program).description,
+            props: read.props
+        });
+        sources.push(...read.sources);
+    }
+    return { docs, sources };
+};
+/**
+ * What a read gave, or why it threw as a message: one file the checker cannot read must not end `forgebook docs` for a
+ * whole package.
+ *
+ * @param file - the file read, for the message.
+ * @param read - the read.
+ */
+const orMessage = (file, read) => {
+    try {
+        return read();
+    }
+    catch (error) {
+        return `${file}: ${error instanceof Error ? error.message : String(error)}`;
+    }
+};
+/** Reads a story file's component; `extractStoryComponent` says what can go wrong. */
+const readStoryComponent = (storyFile) => {
+    const program = svelteProgram(storyFile);
+    if (typeof program === "string")
+        return program;
+    const source = program.program.getSourceFile(storyFile);
+    if (source === undefined)
+        return `${storyFile} is not in its program`;
+    const expression = metaComponent(source);
+    if (expression === undefined)
+        return { docs: { name: null } };
+    const symbol = declaredSymbol(program.checker.getSymbolAtLocation(expression), program.checker);
+    if (symbol === undefined)
+        return `${storyFile}: the meta's component cannot be resolved`;
+    if (isLogic(symbol, program.checker, expression))
+        return logicOf(symbol, expression, program);
+    const subcomponents = subcomponentsOf(source, program);
+    if (typeof subcomponents === "string")
+        return subcomponents;
+    return componentOf(expression.getText(source), symbol, expression, program, subcomponents);
+};
+/**
+ * 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 const extractStoryComponent = (storyFile) => orMessage(storyFile, () => readStoryComponent(storyFile));
+/**
+ * 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 const extractComponentDocs = (storyFile) => {
+    const component = extractStoryComponent(storyFile);
+    return typeof component === "string" ? component : component.docs;
+};
+/** A file's name as a component's (`my-button` → `MyButton`). */
+const pascalCase = (name) => name
+    .split(/[^A-Za-z0-9]+/)
+    .filter((part) => part !== "")
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join("");
+/** Reads a component of a file; `extractFileComponent` says what can go wrong. */
+const readFileComponent = (file, exportName) => {
+    const isComponentFile = extname(file) === COMPONENT_EXTENSION;
+    // a component is read through the TypeScript written for it
+    const read = isComponentFile ? componentScriptFile(file) : file;
+    const program = svelteProgram(read);
+    if (typeof program === "string")
+        return program;
+    const source = program.program.getSourceFile(read);
+    if (source === undefined)
+        return `${file} cannot be read as a component`;
+    const module = program.checker.getSymbolAtLocation(source);
+    if (module === undefined)
+        return `${file} exports nothing`;
+    const exported = program.checker.getExportsOfModule(module);
+    const components = exported
+        .filter((each) => ((declaredSymbol(each, program.checker) ?? each).flags & ts.SymbolFlags.Value) !== 0)
+        .map((each) => each.getName())
+        .filter((name) => (isComponentFile ? name === "default" : /^[A-Z]/.test(name)));
+    const chosen = chosenExport(components, isComponentFile ? "default" : exportName, file);
+    if (typeof chosen !== "string")
+        return chosen.problem;
+    const symbol = exported.find((each) => each.getName() === chosen);
+    if (symbol === undefined)
+        return `${file} exports no component ${chosen}`;
+    const name = isComponentFile ? pascalCase(basename(file, COMPONENT_EXTENSION)) : chosen;
+    return componentOf(name, declaredSymbol(symbol, program.checker) ?? symbol, source, program, {
+        docs: [],
+        sources: []
+    });
+};
+/**
+ * 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 const extractFileComponent = (file, exportName) => orMessage(file, () => readFileComponent(file, exportName));
+/**
+ * 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 const storyFileShape = (name, file) => ({
+    extension: ".stories.ts",
+    importStatement: extname(file) === COMPONENT_EXTENSION
+        ? `import ${name} from ${JSON.stringify(`./${basename(file)}`)};`
+        : `import { ${name} } from ${JSON.stringify(`./${basename(file).replace(/\.[cm]?[jt]s$/, "")}`)};`
+});

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

@@ -0,0 +1,20 @@
+import type { Options as SveltePluginOptions } from "@sveltejs/vite-plugin-svelte";
+import type { FrameworkAdapter } from "forgebook/vite/adapter";
+/** The options of `svelte()`. */
+export type SvelteOptions = {
+    /**
+     * The options of Svelte's Vite plugin (`preprocess`, `compilerOptions`, `extensions`…), over what it reads from the
+     * project's `svelte.config.js`; `configFile: false` reads none. For a project that keeps them elsewhere (SvelteKit 3
+     * writes them in `vite.config`); none by default.
+     */
+    readonly plugin?: Partial<SveltePluginOptions>;
+};
+/**
+ * Svelte, as the plugin reads its components: the docs module the docs' worker loads is this package's `extractDocs.ts`
+ * (the props, snippets and callback props through `svelte2tsx` and TypeScript); the generated pages draw with its renderer
+ * and write code with its markup writer; Vite gets Svelte's plugin, which reads the project's `svelte.config.js`.
+ *
+ * @param options - the options of Svelte's Vite plugin.
+ * @returns the adapter.
+ */
+export declare const svelte: (options?: SvelteOptions) => FrameworkAdapter;

package/dist/src/vite/svelte.js

@@ -0,0 +1,41 @@
+/**
+ * Forgebook's adapter for Svelte, for the Vite plugin: `forgebookPlugin({ framework: svelte() })`.
+ *
+ * @module
+ */
+import { extname } from "node:path";
+import { scriptOf } from "./svelteScript.js";
+/** This package, whose renderer draws with a component of its own. */
+const PACKAGE = "@forgebook/svelte";
+/**
+ * The Vite plugin that has Vite compile this package's component wherever the catalogue's modules run: a test in Node
+ * would otherwise load the package as it is published, and Node cannot load a `.svelte` file.
+ *
+ * @returns the plugin.
+ */
+const ownComponent = () => ({
+    name: "forgebook:svelte-host",
+    config: () => ({ ssr: { noExternal: [PACKAGE] } })
+});
+/**
+ * Svelte, as the plugin reads its components: the docs module the docs' worker loads is this package's `extractDocs.ts`
+ * (the props, snippets and callback props through `svelte2tsx` and TypeScript); the generated pages draw with its renderer
+ * and write code with its markup writer; Vite gets Svelte's plugin, which reads the project's `svelte.config.js`.
+ *
+ * @param options - the options of Svelte's Vite plugin.
+ * @returns the adapter.
+ */
+export const svelte = (options = {}) => ({
+    name: "svelte",
+    // beside this module, with its extension: `.ts` in the sources, `.js` once built for npm
+    docsModule: new URL(`./extractDocs${extname(import.meta.url)}`, import.meta.url).href,
+    pages: { frame: `${PACKAGE}/frame`, code: `${PACKAGE}/code` },
+    // the server render is named too: the page never runs it, but Vite meets its import in the renderer and would reload
+    browserDependencies: ["svelte/server"],
+    componentFiles: { extension: ".svelte", scriptOf },
+    // components and their hot updates: an edited component updates in its frame
+    vitePlugins: async () => {
+        const { svelte: sveltePlugin } = await import("@sveltejs/vite-plugin-svelte");
+        return [sveltePlugin(options.plugin), ownComponent()];
+    }
+});

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

@@ -0,0 +1,13 @@
+/**
+ * The first script of a component: a file with a `<script module>` and a `<script>` opens with either.
+ *
+ * @param text - the file's text.
+ * @returns the script's text; empty when the file has none.
+ */
+export declare const scriptOf: (text: string) => string;
+/**
+ * Whether a component's scripts are TypeScript (`<script lang="ts">`).
+ *
+ * @param text - the file's text.
+ */
+export declare const isTypeScript: (text: string) => boolean;

package/dist/src/vite/svelteScript.js

@@ -0,0 +1,61 @@
+/**
+ * The scripts of a Svelte component, read by Svelte's own parser: the one its opening comment and its `@module` sit in,
+ * and the language it is written in.
+ *
+ * @module
+ */
+import { parse } from "svelte/compiler";
+/**
+ * A component's parsed file, or none when Svelte cannot read it.
+ *
+ * @param text - the file's text.
+ */
+const parsed = (text) => {
+    try {
+        return parse(text, { modern: true });
+    }
+    catch {
+        // a component being edited may not parse for a moment: it has no script to read until it does
+        return undefined;
+    }
+};
+/**
+ * The scripts of a component, in the order the file writes them: `<script module>` and the instance's `<script>`.
+ *
+ * @param root - the parsed file.
+ */
+const scriptsOf = (root) => [root?.module, root?.instance]
+    .filter((script) => script !== undefined && script !== null)
+    .sort((left, right) => left.start - right.start);
+/**
+ * The first script of a component: a file with a `<script module>` and a `<script>` opens with either.
+ *
+ * @param text - the file's text.
+ * @returns the script's text; empty when the file has none.
+ */
+export const scriptOf = (text) => {
+    const [first] = scriptsOf(parsed(text));
+    if (first === undefined)
+        return "";
+    // Svelte's parser places the script's program in the file, which ESTree's type does not say
+    const { content } = first;
+    return "start" in content &&
+        "end" in content &&
+        typeof content.start === "number" &&
+        typeof content.end === "number"
+        ? text.slice(content.start, content.end)
+        : "";
+};
+/** The value an attribute writes, as text; none for an expression or a bare attribute. */
+const attributeText = (attribute) => {
+    const { value } = attribute;
+    if (value === true || !Array.isArray(value))
+        return undefined;
+    return value.map((part) => (part.type === "Text" ? part.data : "")).join("");
+};
+/**
+ * Whether a component's scripts are TypeScript (`<script lang="ts">`).
+ *
+ * @param text - the file's text.
+ */
+export const isTypeScript = (text) => scriptsOf(parsed(text)).some((script) => script.attributes.some((attribute) => attribute.name === "lang" && /^(ts|typescript)$/.test(attributeText(attribute) ?? "")));

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

@@ -0,0 +1,18 @@
+import type { ProgramSources } from "forgebook/vite/docs-program";
+/** A component's extension. */
+export declare const COMPONENT_EXTENSION = ".svelte";
+/**
+ * The file TypeScript reads in a component's place: beside it, `.ts`, or `.js` for one written without TypeScript.
+ *
+ * @param component - the component's file.
+ */
+export declare const componentScriptFile: (component: string) => string;
+/**
+ * The component a file TypeScript asks for stands for, when it does.
+ *
+ * @param fileName - the file TypeScript asks for.
+ * @returns the component's file, or none for a file of its own.
+ */
+export declare const componentOfScriptFile: (fileName: string) => string | undefined;
+/** Svelte's components, as the core's programs read them. */
+export declare const SVELTE_SOURCES: ProgramSources;

package/dist/src/vite/svelteSources.js

@@ -0,0 +1,127 @@
+/**
+ * Svelte components as TypeScript reads them: each `.svelte` file written as the TypeScript it amounts to, by
+ * `svelte2tsx`, the converter Svelte's language server and `svelte-check` use, so a component's props have the types
+ * the editor shows.
+ *
+ * @remarks
+ * The core's programs read these in a component's place (`ProgramSources` of `forgebook/vite/docs-program`): an import
+ * of `./Badge.svelte` looks for `./Badge.svelte.ts` first, and finds the component's TypeScript there; a component
+ * without TypeScript is `./Badge.svelte.js`, so its JSDoc types count. A real `.svelte.ts` module (one with runes) and
+ * the declarations a package publishes beside a component (`Badge.svelte.d.ts`) are read as they are.
+ *
+ * `svelte2tsx` loads `typescript` itself, which a project on TypeScript 7 answers with a package that has no compiler
+ * API: its import is pointed at the TypeScript 6 the core reads with, for that package only, through Node's module hooks.
+ * Its output is text, so which TypeScript wrote it does not matter to the program that reads it.
+ *
+ * @module
+ */
+import { readFileSync, statSync } from "node:fs";
+import { createRequire, registerHooks } from "node:module";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parse, VERSION } from "svelte/compiler";
+import { isTypeScript } from "./svelteScript.js";
+/** Resolves what this module depends on, as Node resolves it from here. */
+const resolveHere = createRequire(import.meta.url).resolve;
+/** The folder `svelte2tsx` is installed in, as a URL with its slash. */
+const SVELTE2TSX_FOLDER = `${pathToFileURL(dirname(resolveHere("svelte2tsx"))).href}/`;
+/** The TypeScript 6 the core reads with. */
+const TYPESCRIPT_6 = pathToFileURL(resolveHere("typescript-6")).href;
+// registered before `svelte2tsx` is first loaded, which the docs' worker does in a thread of its own: a copy loaded
+// earlier in the same thread would keep the TypeScript it found
+registerHooks({
+    resolve: (specifier, context, nextResolve) => specifier === "typescript" && context.parentURL?.startsWith(SVELTE2TSX_FOLDER) === true
+        ? { url: TYPESCRIPT_6, format: "commonjs", shortCircuit: true }
+        : nextResolve(specifier, context)
+});
+const { svelte2tsx } = await import("svelte2tsx");
+/** A component's extension. */
+export const COMPONENT_EXTENSION = ".svelte";
+/** The components written so far, by their file: a program renewed after an edit writes only what changed. */
+const written = new Map();
+/**
+ * Whether a file is on disk.
+ *
+ * @param file - the file.
+ */
+const isFile = (file) => {
+    try {
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * A component's TypeScript, written again only when its text changed.
+ *
+ * @param component - the component's file.
+ * @returns it, or none when there is no such file.
+ */
+const writtenComponent = (component) => {
+    if (!isFile(component))
+        return undefined;
+    const text = readFileSync(component, "utf8");
+    const kept = written.get(component);
+    if (kept?.text === text)
+        return kept;
+    const isTs = isTypeScript(text);
+    let code;
+    try {
+        code = svelte2tsx(text, {
+            filename: component,
+            isTsFile: isTs,
+            mode: "ts",
+            parse,
+            version: VERSION
+        }).code;
+    }
+    catch {
+        // a component that does not parse has no TypeScript: an import of it stays unresolved until it does
+        code = undefined;
+    }
+    const entry = { text, isTypeScript: isTs, code };
+    written.set(component, entry);
+    return entry;
+};
+/**
+ * The file TypeScript reads in a component's place: beside it, `.ts`, or `.js` for one written without TypeScript.
+ *
+ * @param component - the component's file.
+ */
+export const componentScriptFile = (component) => `${component}${writtenComponent(component)?.isTypeScript === false ? ".js" : ".ts"}`;
+/**
+ * The component a file TypeScript asks for stands for, when it does.
+ *
+ * @param fileName - the file TypeScript asks for.
+ * @returns the component's file, or none for a file of its own.
+ */
+export const componentOfScriptFile = (fileName) => {
+    const match = /\.svelte\.([jt]s)$/.exec(fileName);
+    if (match === null)
+        return undefined;
+    const component = fileName.slice(0, -".ts".length);
+    if (isFile(fileName) || isFile(`${component}.d.ts`))
+        return undefined;
+    const entry = writtenComponent(component);
+    if (entry?.code === undefined || entry.isTypeScript !== (match[1] === "ts"))
+        return undefined;
+    return component;
+};
+/**
+ * The text of a file that stands for a component.
+ *
+ * @param fileName - the file TypeScript asks for.
+ */
+const textOf = (fileName) => {
+    const component = componentOfScriptFile(fileName);
+    return component === undefined ? undefined : writtenComponent(component)?.code;
+};
+/** Svelte's components, as the core's programs read them. */
+export const SVELTE_SOURCES = {
+    name: "svelte",
+    textOf,
+    // what the written TypeScript refers to: `svelte2tsx`'s helpers and the elements' attributes
+    roots: [resolveHere("svelte2tsx/svelte-shims-v4.d.ts"), resolveHere("svelte2tsx/svelte-jsx-v4.d.ts")],
+    options: { allowJs: true }
+};

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@forgebook/svelte",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Forgebook for Svelte 5: the story types and the context helpers, the renderer the frame mounts a story with, and the adapter that reads a Svelte component's props, snippets and callback props.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ensiria/forgebook.git",
+    "directory": "packages/svelte"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "sideEffects": [
+    "**/vite/svelteSources.*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/stories.d.ts",
+      "default": "./dist/src/stories.js"
+    },
+    "./clock": {
+      "types": "./dist/src/clock.d.ts",
+      "default": "./dist/src/clock.js"
+    },
+    "./texts": {
+      "types": "./dist/src/texts.d.ts",
+      "default": "./dist/src/texts.js"
+    },
+    "./renderer": {
+      "types": "./dist/src/svelteRenderer.d.ts",
+      "default": "./dist/src/svelteRenderer.js"
+    },
+    "./frame": {
+      "types": "./dist/src/mountFrame.d.ts",
+      "default": "./dist/src/mountFrame.js"
+    },
+    "./code": {
+      "types": "./dist/src/storyMarkup.d.ts",
+      "default": "./dist/src/storyMarkup.js"
+    },
+    "./vite": {
+      "types": "./dist/src/vite/svelte.d.ts",
+      "default": "./dist/src/vite/svelte.js"
+    },
+    "./docs": {
+      "types": "./dist/src/vite/extractDocs.d.ts",
+      "default": "./dist/src/vite/extractDocs.js"
+    }
+  },
+  "dependencies": {
+    "@sveltejs/vite-plugin-svelte": "7.3.1",
+    "svelte2tsx": "0.7.63",
+    "typescript-6": "npm:typescript@6.0.3",
+    "@forgebook/story-format": "0.2.0"
+  },
+  "peerDependencies": {
+    "svelte": "^5.46.4",
+    "forgebook": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "happy-dom": "21.0.4",
+    "svelte": "5.57.3",
+    "svelte-check": "4.7.8",
+    "typescript": "npm:typescript@6.0.3",
+    "vite": "8.3.5",
+    "vitest": "5.0.5",
+    "@forgebook/testing": "0.2.0",
+    "forgebook": "0.2.0",
+    "@forgebook/tools": "0.0.0",
+    "@forgebook/typescript-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "package-build build",
+    "manifest": "package-build manifest",
+    "test": "vitest run",
+    "typecheck": "svelte-check --tsconfig src/tsconfig.json --fail-on-warnings && tsc -p src/vite && svelte-check --tsconfig test/tsconfig.json --fail-on-warnings"
+  }
 }