poveste 0.1.0

package/dist/node/dom/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/node/dom/env.ts"],"names":[],"mappings":"AAMA,wBAAgB,YAAY;;;EAqD3B"}

package/dist/node/dom/env.js

@@ -0,0 +1,47 @@
+import { JSDOM, VirtualConsole, } from 'jsdom';
+import { populateGlobal } from './util.js';
+export function createDomEnv() {
+    const dom = new JSDOM('<!DOCTYPE html>', {
+        pretendToBeVisual: true,
+        runScripts: 'dangerously',
+        url: 'http://localhost:3000',
+        virtualConsole: console && globalThis.console ? new VirtualConsole().forwardTo(globalThis.console) : undefined,
+        includeNodeLocations: false,
+        contentType: 'text/html',
+    });
+    const { keys, originals } = populateGlobal(globalThis, dom.window, { bindFunctions: true });
+    function destroy() {
+        keys.forEach(key => delete globalThis[key]);
+        originals.forEach((v, k) => {
+            globalThis[k] = v;
+        });
+    }
+    window.ResizeObserver = window.ResizeObserver || class ResizeObserver {
+        disconnect() { }
+        observe(_target, _options) { }
+        unobserve(_target) { }
+    };
+    window.IntersectionObserver = window.IntersectionObserver || class IntersectionObserver {
+        root;
+        rootMargin;
+        thresholds;
+        disconnect() { }
+        observe = (_target) => void { /* noop */};
+        unobserve(_target) { }
+        takeRecords() { return []; }
+    };
+    window.matchMedia = window.matchMedia || ((query) => ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: () => { },
+        removeListener: () => { },
+        addEventListener: () => { },
+        removeEventListener: () => { },
+        dispatchEvent: () => false,
+    }));
+    return {
+        window,
+        destroy,
+    };
+}

package/dist/node/dom/util.d.ts

@@ -0,0 +1,11 @@
+export declare function getWindowKeys(global: any, win: any): Set<string>;
+interface PopulateOptions {
+    bindFunctions?: boolean;
+}
+export declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
+    keys: Set<string>;
+    skipKeys: string[];
+    originals: Map<string | symbol, any>;
+};
+export {};
+//# sourceMappingURL=util.d.ts.map

package/dist/node/dom/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/node/dom/util.ts"],"names":[],"mappings":"AAaA,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,eAalD;AAMD,UAAU,eAAe;IAKvB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB;;;;EA0ClF"}

package/dist/node/dom/util.js

@@ -0,0 +1,65 @@
+/*
+ * Code from vitest https://github.com/vitest-dev/vitest/blob/98974ba4a5b95a57a98bc2077b74bc5609d6bb3a/packages/vitest/src/integrations/env/utils.ts#L1 by @antfu and @patak
+ */
+import { KEYS } from './dom-keys.js';
+const skipKeys = [
+    'window',
+    'self',
+    'top',
+    'parent',
+];
+export function getWindowKeys(global, win) {
+    const keys = new Set(KEYS.concat(Object.getOwnPropertyNames(win))
+        .filter((k) => {
+        if (skipKeys.includes(k)) {
+            return false;
+        }
+        if (k in global) {
+            return KEYS.includes(k);
+        }
+        return true;
+    }));
+    return keys;
+}
+function isClassLikeName(name) {
+    return name[0] === name[0].toUpperCase();
+}
+export function populateGlobal(global, win, options = {}) {
+    const { bindFunctions = false } = options;
+    const keys = getWindowKeys(global, win);
+    const originals = new Map();
+    const overrideObject = new Map();
+    for (const key of keys) {
+        const boundFunction = bindFunctions
+            && typeof win[key] === 'function'
+            && !isClassLikeName(key)
+            && win[key].bind(win);
+        if (KEYS.includes(key) && key in global)
+            originals.set(key, global[key]);
+        Object.defineProperty(global, key, {
+            get() {
+                if (overrideObject.has(key))
+                    return overrideObject.get(key);
+                if (boundFunction)
+                    return boundFunction;
+                return win[key];
+            },
+            set(v) {
+                overrideObject.set(key, v);
+            },
+            configurable: true,
+        });
+    }
+    global.window = global;
+    global.self = global;
+    global.top = global;
+    global.parent = global;
+    if (global.global)
+        global.global = global;
+    skipKeys.forEach(k => keys.add(k));
+    return {
+        keys,
+        skipKeys,
+        originals,
+    };
+}

package/dist/node/index.d.ts

@@ -0,0 +1,12 @@
+export { defaultColors } from './colors.js';
+export * from './config.js';
+export * from './plugin.js';
+export * from '@poveste/shared';
+declare module 'rollup' {
+    interface PluginContextMeta {
+        histoire: {
+            isCollecting: boolean;
+        };
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAE/B,OAAO,QAAQ,QAAQ,CAAC;IACtB,UAAU,iBAAiB;QACzB,QAAQ,EAAE;YACR,YAAY,EAAE,OAAO,CAAA;SACtB,CAAA;KACF;CACF"}

package/dist/node/index.js

@@ -0,0 +1,4 @@
+export { defaultColors } from './colors.js';
+export * from './config.js';
+export * from './plugin.js';
+export * from '@poveste/shared';

package/dist/node/load.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleLoader } from '@poveste/shared';
+import type { ViteDevServer } from 'vite';
+export interface UseModuleLoaderOptions {
+    server: ViteDevServer;
+    throws?: boolean;
+}
+export declare function useModuleLoader(options: UseModuleLoaderOptions): ModuleLoader;
+export declare const loadModule: ModuleLoader['loadModule'];
+//# sourceMappingURL=load.d.ts.map

package/dist/node/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/node/load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAMzC,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,YAAY,CA0C7E;AAED,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,YAAY,CAAiC,CAAA"}

package/dist/node/load.js

@@ -0,0 +1,42 @@
+import { resolve } from 'pathe';
+import pc from 'picocolors';
+import { ViteNodeRunner } from 'vite-node/client';
+import { ViteNodeServer } from 'vite-node/server';
+let _load;
+export function useModuleLoader(options) {
+    const { server } = options;
+    const node = new ViteNodeServer(server);
+    const runner = new ViteNodeRunner({
+        root: server.config.root,
+        base: server.config.base,
+        fetchModule: async (id) => node.fetchModule(id),
+        resolveId: (id, importer) => node.resolveId(id, importer),
+    });
+    function clearCache() {
+        server.moduleGraph.invalidateAll();
+        node.fetchCache.clear();
+        runner.moduleCache.clear();
+    }
+    async function loadModule(file) {
+        try {
+            const result = await runner.executeFile(resolve(file));
+            return result;
+        }
+        catch (e) {
+            console.error(pc.red(`Error while loading module ${file}:\n${e.frame ? `${pc.bold(e.message)}\n${e.frame}` : e.stack}`));
+            if (options.throws) {
+                throw e;
+            }
+        }
+    }
+    _load = loadModule;
+    async function destroy() {
+        // Noop
+    }
+    return {
+        clearCache,
+        loadModule,
+        destroy,
+    };
+}
+export const loadModule = (...args) => _load?.(...args);

package/dist/node/markdown.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { Context } from './context.js';
+import MarkdownIt from 'markdown-it';
+export declare function onMarkdownListChange(handler: () => unknown): void;
+export declare function createMarkdownRenderer(ctx: Context): Promise<MarkdownIt>;
+export declare function createMarkdownPlugins(ctx: Context): Promise<VitePlugin<any>[]>;
+export declare function createMarkdownFilesWatcher(ctx: Context): Promise<{
+    stop: () => Promise<void>;
+}>;
+export type MarkdownFilesWatcher = ReturnType<typeof createMarkdownFilesWatcher>;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/node/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/node/markdown.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAA;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAK3C,OAAO,UAAU,MAAM,aAAa,CAAA;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,OAAO,QAE1D;AAQD,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,OAAO,uBAsExD;AAaD,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,OAAO,8BAqBvD;AAED,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,OAAO;;GAgI5D;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/dist/node/markdown.js

@@ -0,0 +1,228 @@
+import { kebabCase } from 'change-case';
+import chokidar from 'chokidar';
+import fs from 'fs-extra';
+import matter from 'gray-matter';
+import MarkdownIt from 'markdown-it';
+import anchor from 'markdown-it-anchor';
+import attrs from 'markdown-it-attrs';
+import { full as emoji } from 'markdown-it-emoji';
+import micromatch from 'micromatch';
+import path from 'pathe';
+import pc from 'picocolors';
+import { bundledLanguages, createHighlighter } from 'shiki';
+import { addStory, notifyStoryChange, removeStory } from './stories.js';
+import { slugify } from './util/slugify.js';
+const onMarkdownListChangeHandlers = [];
+export function onMarkdownListChange(handler) {
+    onMarkdownListChangeHandlers.push(handler);
+}
+function notifyMarkdownListChange() {
+    for (const handler of onMarkdownListChangeHandlers) {
+        handler();
+    }
+}
+export async function createMarkdownRenderer(ctx) {
+    const highlighter = await createHighlighter({
+        themes: ['github-dark'],
+        langs: Object.keys(bundledLanguages), // not ideal but markdown-it does not provide async highlight
+    });
+    const md = new MarkdownIt({
+        highlight: (code, lang) => `<div class="htw-relative htw-not-prose __histoire-code"><div class="htw-absolute htw-top-0 htw-right-0 htw-text-xs htw-text-white/40">${lang}</div>${highlighter.codeToHtml(code, { theme: 'github-dark', lang })}</div>`,
+        linkify: true,
+        html: true,
+        breaks: false,
+    });
+    md.use(anchor, {
+        slugify,
+        permalink: anchor.permalink.ariaHidden({}),
+    })
+        .use(attrs)
+        .use(emoji);
+    // External links
+    {
+        const defaultRender = md.renderer.rules.link_open || function (tokens, idx, options, env, self) {
+            return self.renderToken(tokens, idx, options);
+        };
+        md.renderer.rules.link_open = function (tokens, idx, options, env, self) {
+            const token = tokens[idx];
+            const hrefIndex = token.attrIndex('href');
+            const classIndex = token.attrIndex('class');
+            if (hrefIndex >= 0) {
+                const href = token.attrs[hrefIndex][1];
+                if (href.startsWith('.')) {
+                    const queryIndex = href.indexOf('?');
+                    const pathname = queryIndex >= 0 ? href.slice(0, queryIndex) : href;
+                    const query = queryIndex >= 0 ? href.slice(queryIndex) : '';
+                    // File lookup
+                    const file = path.resolve(path.dirname(env.file), pathname);
+                    const storyFile = ctx.storyFiles.find(f => f.path === file);
+                    const mdFile = ctx.markdownFiles.find(f => f.absolutePath === file);
+                    if (!storyFile && !mdFile?.storyFile) {
+                        throw new Error(pc.red(`[md] Cannot find story file: ${pathname} from ${env.file}`));
+                    }
+                    // Add attributes
+                    const newHref = `${ctx.resolvedViteConfig.base}story/${encodeURIComponent(storyFile?.id ?? mdFile.storyFile.id)}${query}`;
+                    token.attrSet('href', newHref);
+                    token.attrSet('data-route', 'true');
+                }
+                else if (!href.startsWith('/') && !href.startsWith('#') && (classIndex < 0 || !token.attrs[classIndex][1].includes('header-anchor'))) {
+                    // Add target="_blank" to external links
+                    const aIndex = token.attrIndex('target');
+                    if (aIndex < 0) {
+                        token.attrPush(['target', '_blank']); // add new attribute
+                    }
+                    else {
+                        token.attrs[aIndex][1] = '_blank'; // replace value of existing attr
+                    }
+                }
+            }
+            // pass token to default renderer.
+            return defaultRender(tokens, idx, options, env, self);
+        };
+    }
+    return md;
+}
+async function createMarkdownRendererWithPlugins(ctx) {
+    let md = await createMarkdownRenderer(ctx);
+    if (ctx.config.markdown) {
+        const result = await ctx.config.markdown(md);
+        if (result) {
+            md = result;
+        }
+    }
+    return md;
+}
+export async function createMarkdownPlugins(ctx) {
+    const plugins = [];
+    const md = await createMarkdownRendererWithPlugins(ctx);
+    // @TODO extract
+    plugins.push({
+        name: 'histoire-vue-docs-block',
+        transform(code, id) {
+            if (!id.includes('?vue&type=docs'))
+                return;
+            if (!id.includes('lang.md'))
+                return;
+            const file = id.substring(0, id.indexOf('?vue'));
+            const html = md.render(code, {
+                file,
+            });
+            return `export default Comp => {
+        Comp.doc = ${JSON.stringify(html)}
+      }`;
+        },
+    });
+    return plugins;
+}
+export async function createMarkdownFilesWatcher(ctx) {
+    const md = await createMarkdownRendererWithPlugins(ctx);
+    const watcher = chokidar.watch('.', {
+        cwd: ctx.root,
+        ignored: (path, stats) => {
+            if (ctx.config.storyIgnored.some(pattern => micromatch.isMatch(path, pattern))) {
+                return true;
+            }
+            if (micromatch.isMatch(path, '**/*.story.md')) {
+                return false;
+            }
+            return stats?.isFile();
+        },
+    });
+    /**
+     * Initial scan is complete.
+     */
+    let watcherIsReady = false;
+    function addFile(relativePath) {
+        const absolutePath = path.resolve(ctx.root, relativePath);
+        const dirFiles = fs.readdirSync(path.dirname(absolutePath));
+        const truncatedName = path.basename(absolutePath, '.md');
+        const isRelatedToStory = dirFiles.some(file => !file.endsWith('.md') && file.startsWith(truncatedName));
+        const { data: frontmatter, content } = matter(fs.readFileSync(absolutePath, 'utf8'));
+        let html;
+        // We don't immediately render markdown during initial scanning in case
+        // markdown references other files in links (otherwise they might not
+        // be scanned yet and will throw 'not found' errors).
+        if (watcherIsReady) {
+            html = md.render(content, {
+                file: absolutePath,
+            });
+        }
+        const file = {
+            id: kebabCase(relativePath.toLowerCase()),
+            relativePath,
+            absolutePath,
+            isRelatedToStory,
+            frontmatter,
+            content,
+            html,
+        };
+        ctx.markdownFiles.push(file);
+        if (!isRelatedToStory) {
+            const storyRelativePath = relativePath.replace(/\.md$/, '.js');
+            const storyFile = addStory(storyRelativePath, `export default ${JSON.stringify({
+                id: frontmatter.id,
+                title: frontmatter.title,
+                icon: frontmatter.icon ?? 'carbon:document-blank',
+                iconColor: frontmatter.iconColor,
+                group: frontmatter.group,
+                docsOnly: true,
+                variants: [],
+            })}`);
+            file.storyFile = storyFile;
+            storyFile.markdownFile = file;
+            notifyStoryChange(storyFile);
+        }
+        else {
+            const searchPath = path.join(path.dirname(relativePath), truncatedName);
+            const storyFile = ctx.storyFiles.find(f => f.relativePath.startsWith(searchPath));
+            if (storyFile) {
+                file.storyFile = storyFile;
+                storyFile.markdownFile = file;
+                notifyStoryChange(storyFile);
+            }
+        }
+        notifyMarkdownListChange();
+        return file;
+    }
+    function removeFile(relativePath) {
+        const index = ctx.markdownFiles.findIndex(file => file.relativePath === relativePath);
+        if (index !== -1) {
+            const file = ctx.markdownFiles[index];
+            if (!file.isRelatedToStory) {
+                removeStory(file.storyFile.relativePath);
+                notifyStoryChange();
+            }
+            ctx.markdownFiles.splice(index, 1);
+            notifyMarkdownListChange();
+        }
+    }
+    async function stop() {
+        await watcher.close();
+    }
+    watcher
+        .on('add', (relativePath) => {
+        addFile(relativePath);
+    })
+        .on('unlink', (relativePath) => {
+        removeFile(relativePath);
+    });
+    await new Promise((resolve) => {
+        watcher.once('ready', resolve);
+    });
+    try {
+        // Render markdown after initial scan is complete.
+        for (const mdFile of ctx.markdownFiles) {
+            mdFile.html = md.render(mdFile.content, {
+                file: mdFile.absolutePath,
+            });
+        }
+        watcherIsReady = true;
+        return {
+            stop,
+        };
+    }
+    catch (e) {
+        await stop();
+        throw e;
+    }
+}

package/dist/node/plugin.d.ts

@@ -0,0 +1,42 @@
+import type { BuildEndCallback, ChangeViteConfigCallback, ModuleLoader, Plugin, PluginApiBase, PluginApiBuild, PluginApiDev, PluginApiDevEvent, PovesteConfig, PreviewStoryCallback, ServerStory } from '@poveste/shared';
+import type { Context } from './context.js';
+import fs from 'fs-extra';
+import path from 'pathe';
+export declare class BasePluginApi implements PluginApiBase {
+    protected ctx: Context;
+    protected plugin: Plugin;
+    moduleLoader: ModuleLoader;
+    colors: import("picocolors/types.js").Colors & {
+        createColors: (enabled?: boolean) => import("picocolors/types.js").Colors;
+    };
+    path: typeof path;
+    fs: typeof fs;
+    constructor(ctx: Context, plugin: Plugin, moduleLoader: ModuleLoader);
+    get pluginTempDir(): string;
+    log(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    addStoryFile(file: string): void;
+    getStories(): ServerStory[];
+    getConfig(): PovesteConfig;
+}
+export declare class DevPluginApi extends BasePluginApi implements PluginApiDev {
+    watcher: {
+        watch: typeof import("chokidar").watch;
+        FSWatcher: typeof import("chokidar").FSWatcher;
+    };
+}
+export declare class BuildPluginApi extends BasePluginApi implements PluginApiBuild {
+    changeViteConfigCallbacks: ChangeViteConfigCallback[];
+    buildEndCallbacks: BuildEndCallback[];
+    previewStoryCallbacks: PreviewStoryCallback[];
+    changeViteConfig(cb: ChangeViteConfigCallback): void;
+    onBuildEnd(cb: BuildEndCallback): void;
+    onPreviewStory(cb: PreviewStoryCallback): void;
+}
+export declare class DevEventPluginApi extends BasePluginApi implements PluginApiDevEvent {
+    event: string;
+    payload: any;
+    constructor(ctx: Context, plugin: Plugin, moduleLoader: ModuleLoader, event: string, payload: any);
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/node/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/node/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,MAAM,EACN,aAAa,EACb,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,WAAW,EACZ,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,OAAO,EAAE,MAAM,UAAU,CAAA;AACzB,OAAO,IAAI,MAAM,OAAO,CAAA;AAKxB,qBAAa,aAAc,YAAW,aAAa;IAM/C,SAAS,CAAC,GAAG,EAAE,OAAO;IACtB,SAAS,CAAC,MAAM,EAAE,MAAM;IACjB,YAAY,EAAE,YAAY;IAPnC,MAAM;8BAjBH,CAAC;MAiBO;IACX,IAAI,cAAO;IACX,EAAE,YAAK;gBAGK,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY;IAGnC,IAAI,aAAa,WAEhB;IAED,GAAG,CAAC,GAAG,GAAG,OAAA;IAIV,IAAI,CAAC,GAAG,GAAG,OAAA;IAIX,KAAK,CAAC,GAAG,GAAG,OAAA;IAIZ,YAAY,CAAC,IAAI,EAAE,MAAM;IAKzB,UAAU,IAAI,WAAW,EAAE;IAI3B,SAAS,IAAI,aAAa;CAG3B;AAED,qBAAa,YAAa,SAAQ,aAAc,YAAW,YAAY;IACrE,OAAO;;;MAAW;CACnB;AAED,qBAAa,cAAe,SAAQ,aAAc,YAAW,cAAc;IACzE,yBAAyB,EAAE,wBAAwB,EAAE,CAAK;IAC1D,iBAAiB,EAAE,gBAAgB,EAAE,CAAK;IAC1C,qBAAqB,EAAE,oBAAoB,EAAE,CAAK;IAElD,gBAAgB,CAAC,EAAE,EAAE,wBAAwB;IAI7C,UAAU,CAAC,EAAE,EAAE,gBAAgB;IAI/B,cAAc,CAAC,EAAE,EAAE,oBAAoB;CAGxC;AAED,qBAAa,iBAAkB,SAAQ,aAAc,YAAW,iBAAiB;IAKtE,KAAK,EAAE,MAAM;IACb,OAAO,EAAE,GAAG;gBAJnB,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,GAAG;CAItB"}

package/dist/node/plugin.js

@@ -0,0 +1,67 @@
+import chokidar from 'chokidar';
+import fs from 'fs-extra';
+import path from 'pathe';
+import pc from 'picocolors';
+import { TEMP_PATH } from './alias.js';
+import { addStory, removeStory } from './stories.js';
+export class BasePluginApi {
+    ctx;
+    plugin;
+    moduleLoader;
+    colors = pc;
+    path = path;
+    fs = fs;
+    constructor(ctx, plugin, moduleLoader) {
+        this.ctx = ctx;
+        this.plugin = plugin;
+        this.moduleLoader = moduleLoader;
+    }
+    get pluginTempDir() {
+        return path.resolve(TEMP_PATH, 'plugins', this.plugin.name.replace(/:/g, '_'));
+    }
+    log(...msg) {
+        console.log(this.colors.gray(`[Plugin:${this.plugin.name}]`), ...msg);
+    }
+    warn(...msg) {
+        console.warn(this.colors.yellow(`[Plugin:${this.plugin.name}]`), ...msg);
+    }
+    error(...msg) {
+        console.error(this.colors.red(`[Plugin:${this.plugin.name}]`), ...msg);
+    }
+    addStoryFile(file) {
+        removeStory(file);
+        addStory(file);
+    }
+    getStories() {
+        return this.ctx.storyFiles.map(f => f.story).filter(Boolean);
+    }
+    getConfig() {
+        return this.ctx.config;
+    }
+}
+export class DevPluginApi extends BasePluginApi {
+    watcher = chokidar;
+}
+export class BuildPluginApi extends BasePluginApi {
+    changeViteConfigCallbacks = [];
+    buildEndCallbacks = [];
+    previewStoryCallbacks = [];
+    changeViteConfig(cb) {
+        this.changeViteConfigCallbacks.push(cb);
+    }
+    onBuildEnd(cb) {
+        this.buildEndCallbacks.push(cb);
+    }
+    onPreviewStory(cb) {
+        this.previewStoryCallbacks.push(cb);
+    }
+}
+export class DevEventPluginApi extends BasePluginApi {
+    event;
+    payload;
+    constructor(ctx, plugin, moduleLoader, event, payload) {
+        super(ctx, plugin, moduleLoader);
+        this.event = event;
+        this.payload = payload;
+    }
+}

package/dist/node/preview.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from './context.js';
+interface ReturnPayload {
+    baseUrl: string;
+    close: () => Promise<void>;
+}
+export declare function startPreview(port: number | null, ctx: Context): Promise<ReturnPayload>;
+export {};
+//# sourceMappingURL=preview.d.ts.map

package/dist/node/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/node/preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAK3C,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CA8C5F"}

package/dist/node/preview.js

@@ -0,0 +1,41 @@
+import http from 'node:http';
+import connect from 'connect';
+import sirv from 'sirv';
+export async function startPreview(port, ctx) {
+    const app = connect();
+    app.use(ctx.resolvedViteConfig.base, sirv(ctx.config.outDir, {
+        dev: true,
+        etag: true,
+        single: true,
+    }));
+    let finalPort = port ?? 6006;
+    const httpServer = http.createServer(app);
+    return new Promise((resolve, reject) => {
+        function onError(e) {
+            if (e.code === 'EADDRINUSE') {
+                httpServer.listen(++finalPort);
+            }
+            else {
+                reject(e);
+            }
+        }
+        httpServer.on('error', onError);
+        httpServer.listen(finalPort, () => {
+            httpServer.off('error', onError);
+            const baseUrl = `http://localhost:${finalPort}${ctx.resolvedViteConfig.base}`;
+            resolve({
+                baseUrl,
+                close: () => new Promise((resolve, reject) => {
+                    httpServer.close((err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                }),
+            });
+        });
+    });
+}

package/dist/node/search.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from './context.js';
+export declare function generateTitleSearchData(ctx: Context): Promise<{
+    index: any[];
+    idMap: Record<number, {
+        id: string;
+        kind: string;
+    }>;
+}>;
+export declare function generateDocSearchData(ctx: Context): Promise<{
+    index: any[];
+    idMap: Record<number, {
+        id: string;
+        kind: string;
+    }>;
+}>;
+export declare function getSearchDataJS(data: any): string;
+//# sourceMappingURL=search.d.ts.map

package/dist/node/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/node/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,OAAO;;;YA8CtB,MAAM;cAAQ,MAAM;;GAvBvD;AAED,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,OAAO;;;YAqBpB,MAAM;cAAQ,MAAM;;GAJvD;AAuBD,wBAAgB,eAAe,CAAC,IAAI,EAAE,GAAG,UAexC"}