poveste 0.1.0

package/dist/node/virtual/vite-plugin.js

@@ -0,0 +1,126 @@
+import { resolve } from 'pathe';
+import { generateDocSearchData, generateTitleSearchData, getSearchDataJS } from '../search.js';
+import * as VirtualFiles from './index.js';
+import { ID_SEPARATOR } from './util.js';
+export function createVirtualFilesPlugin(ctx, isServer) {
+    return {
+        name: 'histoire-virtual-files',
+        async resolveId(id, importer) {
+            if (id.startsWith(VirtualFiles.STORIES_ID)) {
+                return VirtualFiles.RESOLVED_STORIES_ID;
+            }
+            if (id.startsWith(VirtualFiles.SETUP_ID)) {
+                const setupFileConfig = ctx.config.setupFile;
+                if (setupFileConfig) {
+                    let file;
+                    if (typeof setupFileConfig === 'string') {
+                        file = setupFileConfig;
+                    }
+                    else if (isServer && 'server' in setupFileConfig) {
+                        file = setupFileConfig.server;
+                    }
+                    else if (!isServer && 'browser' in setupFileConfig) {
+                        file = setupFileConfig.browser;
+                    }
+                    if (file) {
+                        return this.resolve(resolve(ctx.root, file), importer, {
+                            skipSelf: true,
+                        });
+                    }
+                }
+                return VirtualFiles.NOOP_ID;
+            }
+            if (id.startsWith(VirtualFiles.CONFIG_ID)) {
+                return VirtualFiles.RESOLVED_CONFIG_ID;
+            }
+            if (id.startsWith(VirtualFiles.THEME_ID)) {
+                return VirtualFiles.RESOLVED_THEME_ID;
+            }
+            if (id.startsWith(VirtualFiles.SEARCH_TITLE_DATA_ID)) {
+                return VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID;
+            }
+            if (id.startsWith(VirtualFiles.SEARCH_DOCS_DATA_ID)) {
+                return VirtualFiles.RESOLVED_SEARCH_DOCS_DATA_ID;
+            }
+            if (id.startsWith(VirtualFiles.GENERATED_GLOBAL_SETUP)) {
+                return VirtualFiles.RESOLVED_GENERATED_GLOBAL_SETUP;
+            }
+            if (id.startsWith(VirtualFiles.GENERATED_SETUP_CODE)) {
+                const [, index] = id.split(ID_SEPARATOR);
+                return `${VirtualFiles.RESOLVED_GENERATED_SETUP_CODE}${ID_SEPARATOR}${index}`;
+            }
+            if (id.startsWith(VirtualFiles.SUPPORT_PLUGINS_CLIENT)) {
+                return VirtualFiles.RESOLVED_SUPPORT_PLUGINS_CLIENT;
+            }
+            if (id.startsWith(VirtualFiles.SUPPORT_PLUGINS_COLLECT)) {
+                return VirtualFiles.RESOLVED_SUPPORT_PLUGINS_COLLECT;
+            }
+            if (id.startsWith(VirtualFiles.MARKDOWN_FILES)) {
+                return VirtualFiles.RESOLVED_MARKDOWN_FILES;
+            }
+            if (id.startsWith(VirtualFiles.COMMANDS)) {
+                return VirtualFiles.RESOLVED_COMMANDS;
+            }
+            if (id.startsWith('virtual:story:')) {
+                return `\0${id}`;
+            }
+            if (id.startsWith('virtual:story-source:')) {
+                return `/__resolved__${id}`;
+                // @TODO
+                // return `\0${id}`
+            }
+            if (id.startsWith('virtual:md:')) {
+                return `/__resolved__${id}`;
+                // @TODO
+                // return `\0${id}`
+            }
+        },
+        async load(id) {
+            if (id === VirtualFiles.RESOLVED_STORIES_ID) {
+                return VirtualFiles.resolvedStories(ctx);
+            }
+            if (id === VirtualFiles.NOOP_ID) {
+                return VirtualFiles.noop();
+            }
+            if (id === VirtualFiles.RESOLVED_CONFIG_ID) {
+                return VirtualFiles.resolvedConfig(ctx);
+            }
+            if (id === VirtualFiles.RESOLVED_THEME_ID) {
+                return VirtualFiles.resolvedTheme(ctx);
+            }
+            if (id === VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID) {
+                return getSearchDataJS(await generateTitleSearchData(ctx));
+            }
+            if (id === VirtualFiles.RESOLVED_SEARCH_DOCS_DATA_ID) {
+                return getSearchDataJS(await generateDocSearchData(ctx));
+            }
+            if (id === VirtualFiles.RESOLVED_GENERATED_GLOBAL_SETUP) {
+                return VirtualFiles.resolvedGeneratedGlobalSetup(ctx);
+            }
+            if (id.startsWith(VirtualFiles.RESOLVED_GENERATED_SETUP_CODE)) {
+                return VirtualFiles.resolvedGeneratedSetupCode(ctx, id);
+            }
+            if (id === VirtualFiles.RESOLVED_SUPPORT_PLUGINS_CLIENT) {
+                return VirtualFiles.resolvedSupportPluginsClient(ctx);
+            }
+            if (id === VirtualFiles.RESOLVED_SUPPORT_PLUGINS_COLLECT) {
+                return VirtualFiles.resolvedSupportPluginsCollect(ctx);
+            }
+            if (id === VirtualFiles.RESOLVED_MARKDOWN_FILES) {
+                return VirtualFiles.resolvedMarkdownFiles(ctx);
+            }
+            if (id === VirtualFiles.RESOLVED_COMMANDS) {
+                return VirtualFiles.resolvedCommands(ctx);
+            }
+            if (id.startsWith('\0virtual:story:')) {
+                return VirtualFiles.story(ctx, id);
+            }
+            if (id.startsWith('/__resolved__virtual:story-source:')) {
+                return VirtualFiles.storySource(ctx, id);
+            }
+            if (id.startsWith('/__resolved__virtual:md:')) {
+                return VirtualFiles.markdown(ctx, id);
+            }
+        },
+    };
+}

package/dist/node/vite.d.ts

@@ -0,0 +1,9 @@
+import type { InlineConfig } from 'vite';
+import type { Context } from './context.js';
+export declare function mergeHistoireViteConfig(viteConfig: InlineConfig, ctx: Context): Promise<InlineConfig>;
+export interface ViteConfigWithPlugins {
+    viteConfig: InlineConfig;
+    viteConfigFile: string | null;
+}
+export declare function getViteConfigWithPlugins(isServer: boolean, ctx: Context): Promise<ViteConfigWithPlugins>;
+//# sourceMappingURL=vite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/node/vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAe3C,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,yBAmCnF;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,YAAY,CAAA;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA4T9G"}

package/dist/node/vite.js

@@ -0,0 +1,337 @@
+import { createRequire } from 'node:module';
+import { lookup as lookupMime } from 'mrmime';
+import { dirname, join, relative } from 'pathe';
+import { loadConfigFromFile as loadViteConfigFromFile, mergeConfig as mergeViteConfig, } from 'vite';
+import { APP_PATH, TEMP_PATH } from './alias.js';
+import { createMarkdownPlugins } from './markdown.js';
+import { notifyStoryChange } from './stories.js';
+import { createVirtualFilesPlugin } from './virtual/vite-plugin.js';
+const require = createRequire(import.meta.url);
+export async function mergeHistoireViteConfig(viteConfig, ctx) {
+    if (ctx.config.vite) {
+        const command = ctx.mode === 'dev' ? 'serve' : 'build';
+        const overrides = typeof ctx.config.vite === 'function'
+            ? await ctx.config.vite(viteConfig, {
+                mode: ctx.mode,
+                command,
+            })
+            : ctx.config.vite;
+        if (overrides) {
+            viteConfig = mergeViteConfig(viteConfig, overrides);
+        }
+    }
+    let flatPlugins = [];
+    if (viteConfig.plugins) {
+        for (const pluginOption of viteConfig.plugins) {
+            const resolvedPluginOption = await pluginOption;
+            if (Array.isArray(resolvedPluginOption)) {
+                flatPlugins.push(...await Promise.all(resolvedPluginOption));
+            }
+            else {
+                flatPlugins.push(resolvedPluginOption);
+            }
+        }
+        flatPlugins = flatPlugins.filter(Boolean);
+    }
+    if (ctx.config.viteIgnorePlugins) {
+        flatPlugins = flatPlugins.filter(plugin => !ctx.config.viteIgnorePlugins.includes(plugin.name));
+    }
+    viteConfig.plugins = flatPlugins;
+    return viteConfig;
+}
+export async function getViteConfigWithPlugins(isServer, ctx) {
+    const userViteConfigFile = await loadViteConfigFromFile({ command: ctx.mode === 'dev' ? 'serve' : 'build', mode: ctx.mode });
+    const userViteConfig = mergeViteConfig(userViteConfigFile?.config ?? {}, { server: { port: 6006 } });
+    const inlineConfig = await mergeHistoireViteConfig(userViteConfig, ctx);
+    const plugins = [];
+    const supportPluginAllowPaths = ctx.supportPlugins.flatMap((plugin) => {
+        const paths = [ctx.root, import.meta.url];
+        const result = new Set();
+        for (const suffix of ['', '/client', '/collect']) {
+            try {
+                const resolved = require.resolve(`${plugin.moduleName}${suffix}`, {
+                    paths,
+                });
+                result.add(dirname(resolved));
+            }
+            catch {
+                // Noop
+            }
+        }
+        return Array.from(result);
+    });
+    function optimizeDeps(deps) {
+        const result = [];
+        for (const dep of deps) {
+            result.push(dep);
+            try {
+                result.push(dirname(require.resolve(`${dep}/package.json`)));
+            }
+            catch (e) {
+                // Noop
+            }
+        }
+        return result;
+    }
+    plugins.push({
+        name: 'histoire-vite-plugin',
+        config(_, { command }) {
+            return {
+                resolve: {
+                    dedupe: [
+                        'vue',
+                    ],
+                    alias: {
+                        'histoire-style': join(APP_PATH, process.env.HISTOIRE_DEV ? 'app/style/main.pcss' : 'style.css'),
+                    },
+                    ...(isServer
+                        ? {
+                            // Force resolving deps like Node.JS resolution algorithm (in case some modules are not loaded with ssr: true e.g. .vue files)
+                            conditions: ['node'],
+                        }
+                        : {}),
+                },
+                optimizeDeps: {
+                    entries: [
+                        `${APP_PATH}/bundle-main.js`,
+                        `${APP_PATH}/bundle-sandbox.js`,
+                    ],
+                    include: optimizeDeps([
+                        'flexsearch',
+                        'shiki',
+                        // Shiki dependencies
+                        'vscode-oniguruma',
+                        'vscode-textmate',
+                    ]),
+                    exclude: [
+                        'poveste',
+                        '@poveste/vendors',
+                    ],
+                },
+                server: {
+                    fs: {
+                        allow: [
+                            APP_PATH,
+                            TEMP_PATH,
+                            ctx.resolvedViteConfig.root,
+                            process.cwd(),
+                            ...supportPluginAllowPaths,
+                            ...process.env.HISTOIRE_DEV
+                                ? [
+                                    '../../packages/histoire-vendors',
+                                ]
+                                : [],
+                        ],
+                    },
+                    watch: {
+                        ignored: [`!**/node_modules/.histoire/**`, '**/vite.config.*'],
+                    },
+                    hmr: command === 'build' ? false : !isServer,
+                },
+                define: {
+                    // We need to force this to be able to use `devtoolsRawSetupState`
+                    '__VUE_PROD_DEVTOOLS__': 'true',
+                    // Disable warnings
+                    'process.env.NODE_ENV': JSON.stringify(isServer ? 'production' : process.env.NODE_ENV ?? 'development'),
+                    ...!isServer
+                        ? {
+                            // Collect flag
+                            'process.env.HST_COLLECT': 'false',
+                        }
+                        : {},
+                    '__HST_COLLECT__': isServer,
+                },
+                cacheDir: isServer ? 'node_modules/.hst-vite-server' : 'node_modules/.hst-vite',
+            };
+        },
+        options() {
+            this.meta.histoire = {
+                isCollecting: isServer,
+            };
+        },
+        handleHotUpdate(updateContext) {
+            const story = ctx.storyFiles.find(file => file.path === updateContext.file);
+            if (story) {
+                notifyStoryChange(story);
+            }
+        },
+        configureServer(server) {
+            let firstMount = true;
+            server.ws.on('histoire:mount', () => {
+                if (!firstMount) {
+                    notifyStoryChange();
+                }
+                firstMount = false;
+            });
+            server.middlewares.use(async (req, res, next) => {
+                if (req.url.startsWith(`${server.config.base}__sandbox`)) {
+                    res.statusCode = 200;
+                    let html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title></title>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="description" content="">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+  // Hide spammy vite messages
+  const origConsoleLog = console.log
+  console.log = (...args) => {
+    if (typeof args[0] !== 'string' || !args[0].startsWith('[vite] connect')) {
+      origConsoleLog(...args)
+    }
+  }
+  </script>
+  <script type="module" src="/@fs/${APP_PATH}/bundle-sandbox${process.env.HISTOIRE_DEV ? '-dev' : ''}.js"></script>
+</body>
+</html>`;
+                    // Apply Vite HTML transforms. This injects the Vite HMR client, and
+                    // also applies HTML transforms from Vite plugins
+                    html = await server.transformIndexHtml(req.url, html);
+                    res.setHeader('content-type', 'text/html; charset=UTF-8');
+                    res.end(html);
+                    return;
+                }
+                next();
+            });
+            // serve our index.html after vite history fallback
+            return () => {
+                server.middlewares.use(async (req, res, next) => {
+                    if (req.url.endsWith('.html')) {
+                        res.statusCode = 200;
+                        let html = `
+<!DOCTYPE html>
+<html>
+  <head>
+    <title></title>
+    <link rel="icon" href=""/>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="description" content="">
+    ${ctx.config.theme?.favicon ? `<link rel="icon" type="${lookupMime(ctx.config.theme.favicon)}" href="${server.config.base}${ctx.config.theme.favicon}"/>` : ''}
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/@fs/${APP_PATH}/bundle-main${process.env.HISTOIRE_DEV ? '-dev' : ''}.js"></script>
+  </body>
+</html>`;
+                        // Apply Vite HTML transforms. This injects the Vite HMR client, and
+                        // also applies HTML transforms from Vite plugins
+                        html = await server.transformIndexHtml(req.url, html);
+                        res.setHeader('content-type', 'text/html; charset=UTF-8');
+                        res.end(html);
+                        return;
+                    }
+                    next();
+                });
+            };
+        },
+    });
+    plugins.push(createVirtualFilesPlugin(ctx, isServer));
+    // Replace dev flag
+    const flags = {
+        '_ctx.__HISTOIRE_DEV__': JSON.stringify(ctx.mode === 'dev'),
+        '__HISTOIRE_DEV__': JSON.stringify(ctx.mode === 'dev'),
+    };
+    plugins.push({
+        name: 'histoire:flags',
+        enforce: 'pre',
+        transform(code, id) {
+            if (id.match(/\.(vue|js)($|\?)/)) {
+                const original = code;
+                for (const flag in flags) {
+                    code = code.replace(new RegExp(flag, 'g'), flags[flag]);
+                }
+                if (original !== code)
+                    return code;
+            }
+        },
+    });
+    if (ctx.mode === 'dev') {
+        // Dev commands
+        plugins.push({
+            name: 'histoire:dev-commands',
+            configureServer(server) {
+                server.ws.on('histoire:dev-command', ({ id, params }) => {
+                    const command = ctx.registeredCommands.find(c => c.id === id);
+                    if (command?.serverAction) {
+                        command.serverAction(params);
+                    }
+                });
+            },
+        });
+    }
+    // Markdown
+    plugins.push(...await createMarkdownPlugins(ctx));
+    if (ctx.mode === 'build') {
+        // Add file name in build mode to have components names instead of <Anonymous>
+        const include = [/\.vue$/];
+        const exclude = [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/, /[\\/]\.nuxt[\\/]/];
+        plugins.push({
+            name: 'histoire-file-name-plugin',
+            enforce: 'post',
+            transform(code, id) {
+                if (exclude.some(r => r.test(id)))
+                    return;
+                if (include.some(r => r.test(id))) {
+                    const file = relative(ctx.resolvedViteConfig.root, id);
+                    const index = code.indexOf('export default');
+                    const result = `${code.substring(0, index)}_sfc_main.__file = '${file}'\n${code.substring(index)}`;
+                    return result;
+                }
+            },
+        });
+    }
+    if (process.env.HISTOIRE_DEV && !isServer) {
+        plugins.push({
+            name: 'histoire-dev-plugin',
+            config() {
+                // Examples context
+                return {
+                    resolve: {
+                        alias: [
+                            ...[
+                                ['floating-vue/dist/style.css', 'node_modules/floating-vue/dist/style.css'],
+                                ['floating-vue', 'floating-vue'],
+                                ['@iconify/vue', 'iconify'],
+                                ['pinia', 'pinia'],
+                                ['scroll-into-view-if-needed', 'scroll'],
+                                ['vue-router', 'vue-router'],
+                                ['@vueuse/core', 'vue-use'],
+                                ['vue', 'vue'],
+                            ].reduce((acc, [name, entry]) => {
+                                acc.push({
+                                    find: new RegExp(`^${name.replace(/\//g, '\\/')}$`),
+                                    replacement: `@poveste/vendors/${entry}`,
+                                });
+                                acc.push({
+                                    find: new RegExp(`^${name.replace(/\//g, '\\/')}\\/`),
+                                    replacement: `@poveste/vendors/${entry}/`,
+                                });
+                                return acc;
+                            }, []),
+                            { find: /@histoire\/controls$/, replacement: '@poveste/controls/src/index.ts' },
+                        ],
+                    },
+                };
+            },
+        });
+    }
+    for (const plugin of ctx.config.plugins) {
+        if (plugin.vitePlugins) {
+            await plugin.vitePlugins(plugins);
+        }
+    }
+    const viteConfig = mergeViteConfig(inlineConfig, {
+        configFile: false,
+        plugins,
+    });
+    return {
+        viteConfig,
+        viteConfigFile: userViteConfigFile?.path ?? null,
+    };
+}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/node/index'

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "poveste",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "A fast story book powered by Vite",
+  "author": {
+    "name": "Sorin Gitlan"
+  },
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/poveste-dev/poveste.git",
+    "type": "git",
+    "directory": "packages/poveste"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./client": {
+      "types": "./client.d.ts",
+      "default": "./client.js"
+    },
+    "./plugin": {
+      "types": "./plugin.d.ts",
+      "default": "./plugin.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/node/index.js",
+  "module": "./dist/node/index.js",
+  "types": "./index.d.ts",
+  "bin": {
+    "poveste": "./bin.mjs",
+    "histoire": "./bin.mjs"
+  },
+  "peerDependencies": {
+    "vite": "^7.0.0 || ^8.0.0"
+  },
+  "dependencies": {
+    "@akryum/tinypool": "^0.3.1",
+    "@types/markdown-it": "^14.1.2",
+    "birpc": "^0.2.19",
+    "change-case": "^5.4.4",
+    "chokidar": "^4.0.1",
+    "connect": "^3.7.0",
+    "defu": "^6.1.4",
+    "diacritics": "^1.3.0",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.0.2",
+    "gray-matter": "^4.0.3",
+    "jiti": "^2.4.1",
+    "jsdom": "^27.4.0",
+    "markdown-it": "^14.1.0",
+    "markdown-it-anchor": "^9.2.0",
+    "markdown-it-attrs": "^4.3.0",
+    "markdown-it-emoji": "^3.0.0",
+    "micromatch": "^4.0.8",
+    "mrmime": "^2.0.0",
+    "pathe": "^1.1.2",
+    "picocolors": "^1.1.1",
+    "sade": "^1.8.1",
+    "shiki": "^3.0.0",
+    "sirv": "^3.0.0",
+    "vite-node": "3.2.4",
+    "@poveste/app": "^0.1.0",
+    "@poveste/controls": "^0.1.0",
+    "@poveste/shared": "^0.1.0",
+    "@poveste/vendors": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.1",
+    "esbuild": "^0.27.2",
+    "rollup": "^4.28.0",
+    "typescript": "5.6.3",
+    "vite": "^7.3.0",
+    "vitest": "4.0.16"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "watch": "tsc -w --sourceMap",
+    "test": "vitest run",
+    "test:dev": "vitest"
+  }
+}

package/plugin.d.ts

@@ -0,0 +1,3 @@
+export function sendEvent(event: string, payload?: any): Promise<any>
+
+export function openStory(storyId: string): void

package/plugin.js

@@ -0,0 +1,11 @@
+export function sendEvent(event, payload) {
+  if (window.__HST_PLUGIN_API__) {
+    return window.__HST_PLUGIN_API__.sendEvent(event, payload)
+  }
+}
+
+export function openStory(storyId) {
+  if (window.__HST_PLUGIN_API__) {
+    return window.__HST_PLUGIN_API__.openStory(storyId)
+  }
+}

package/src/controls.ts

@@ -0,0 +1 @@
+export * from '@poveste/controls'

package/src/node/__tests__/markdown/test1.story.md

@@ -0,0 +1,7 @@
+<!-- File should link to test2 file. -->
+<!-- File should return test2 successfully, even though test1 loads before test2. -->
+
+# Test1
+
+Link to test 2
+[Test2](./test2.story.md)

package/src/node/__tests__/markdown/test2.story.md

@@ -0,0 +1,5 @@
+<!-- File should link to test1 file. -->
+# Test2
+
+Link to test 1
+[Test1](./test1.story.md)

package/src/node/__tests__/markdown.spec.ts

@@ -0,0 +1,61 @@
+import type { Context } from '../context.js'
+import { createWriteStream, unlinkSync } from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createContext } from '../context.js'
+import { createMarkdownFilesWatcher } from '../markdown.js'
+import { watchStories } from '../stories.js'
+
+describe('markdown', async () => {
+  vi.spyOn(process, 'cwd').mockReturnValue(path.resolve(__dirname, './markdown'))
+
+  let ctx: Context
+  let storyWatcher: Awaited<ReturnType<typeof watchStories>>
+
+  beforeEach(async () => {
+    ctx = await createContext({
+      mode: 'dev',
+    })
+
+    // create watch stories to set context root etc.
+    storyWatcher = await watchStories(ctx)
+  })
+
+  afterEach(() => {
+    storyWatcher.close()
+  })
+
+  it('should not throw error or depend on - resolve order for linking', async () => {
+    // FileWatcher should pickup the test markdown files (test1 and test2)
+    // test1 links to test2 (issue previously as test1 resolved first)
+    // test 2 links to test1
+    const { stop } = await createMarkdownFilesWatcher(ctx)
+    expect(ctx.markdownFiles.length).toEqual(2)
+    stop()
+  })
+
+  it('should render html from md', async () => {
+    const { stop } = await createMarkdownFilesWatcher(ctx)
+    expect(ctx.markdownFiles[0].html).toContain('<p>')
+    stop()
+  })
+
+  it('should throw error on missing [md] story file.', async () => {
+    const testFile3 = '/markdown/test3.story.md'
+    const writer = createWriteStream(__dirname.concat(testFile3))
+    // link to missing file.
+    writer.write(
+      '<!-- File should link to test1 file. -->\n'
+      + '# Test3\n\n'
+      + 'Link to test 4\n'
+      + '[TEST](./test4.story.md)\n',
+    )
+    writer.end()
+    await new Promise(resolve => writer.on('finish', resolve))
+
+    // create markdownWatcher and check for error
+    await expect(async () => createMarkdownFilesWatcher(ctx)).rejects.toThrowError()
+    // delete test file, so failures are removed as well.
+    unlinkSync(__dirname.concat(testFile3))
+  })
+})