@forgebook/sveltekit 0.0.0-stage → 0.2.0

package/dist/src/kitRenderer.js

@@ -0,0 +1,254 @@
+/**
+ * Forgebook's renderer for a SvelteKit project: Svelte's renderer, each story given its page (`$app/state`), its
+ * page's data loaded by its `load` before it is drawn, and its links kept in the story.
+ *
+ * @remarks
+ * A story's page (`parameters.sveltekit`) lives in a store made when the story is mounted, so a story drawn again with
+ * other args keeps where its links took it, and one that starts over starts at its own page. A story that gives its
+ * page data (`page.data`, `serverData` or `load`) or an action's answer (`forms.result`) is a page's: its component
+ * gets `data`, `form` and `params`, as SvelteKit
+ * draws a `+page.svelte`, unless its args give them. Every link the story draws is caught, so the frame stays on its
+ * story: one of the app moves the story's page, one an `hrefs` entry names calls it instead, and each is listed among
+ * the story's events. Everything else is Svelte's renderer (`@forgebook/svelte/renderer`), which this one wraps.
+ *
+ * @module
+ */
+import { svelteRenderer } from "@forgebook/svelte/renderer";
+import { hrefCallbacksOf } from "./kitParameters.js";
+import { createKitStore, errorOfThrown, setCurrentStore } from "./kitStore.js";
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** An error as the frame takes it: SvelteKit's `error(404, "…")` written with its status. */
+const toError = (error) => {
+    if (error instanceof Error)
+        return error;
+    const read = errorOfThrown(error);
+    return new Error(`${read.status ?? 500}: ${read.message}`);
+};
+/**
+ * The address a load fetches: in a page, as the frame's `fetch` reads it, so the catalogue's mocks answer a path; on a
+ * server, which has no page to read a path from, from the story's page, as SvelteKit's `fetch` does.
+ *
+ * @param input - what the load fetches.
+ * @param pageUrl - the story's page.
+ */
+const pageRequest = (input, pageUrl) => typeof location === "undefined" ? new URL(input, pageUrl).href : input;
+/**
+ * The loader of a story's page data: its loads in order, the layouts' first, each `parent()` the data above it.
+ *
+ * @param kit - the story's settings.
+ * @param store - the story's page, which records what the loads call.
+ * @returns the loader, or none for a story that gives no load and no server data.
+ */
+const loaderOf = (kit, store) => {
+    if (kit.loads.length === 0 && kit.serverData === null)
+        return undefined;
+    return async (at) => {
+        let merged = kit.page.data;
+        if (kit.loads.length === 0)
+            return { ...merged, ...kit.serverData };
+        for (const [index, load] of kit.loads.entries()) {
+            const above = merged;
+            const isPage = index === kit.loads.length - 1;
+            const result = await load({
+                params: at.params,
+                url: at.url,
+                route: at.route,
+                fetch: (input, init) => globalThis.fetch(typeof input === "string" ? pageRequest(input, at.url) : input, init),
+                // the page's server data is the page's load's; a layout's server load is given by `page.data`
+                data: isPage ? kit.serverData : null,
+                parent: async () => above,
+                depends: (...dependencies) => store.record("depends", dependencies),
+                setHeaders: () => undefined,
+                untrack: (read) => read()
+            });
+            merged = { ...merged, ...(isRecord(result) ? result : {}) };
+        }
+        return merged;
+    };
+};
+/**
+ * The drawing Svelte's renderer gets: a page's component given its data, form and params, unless its args give them.
+ *
+ * @param drawing - the drawing the frame gave.
+ * @param store - the story's page.
+ */
+const withPage = (drawing, store) => {
+    if (!store.kit.isPage)
+        return drawing;
+    const page = store.page();
+    return {
+        ...drawing,
+        args: {
+            ...("data" in drawing.args ? {} : { data: page.data }),
+            ...("form" in drawing.args ? {} : { form: page.form }),
+            // SvelteKit 3 gives a page its route's params too
+            ...("params" in drawing.args ? {} : { params: page.params }),
+            ...drawing.args
+        }
+    };
+};
+/**
+ * The href of the link an event went through, as written: an `<a>` (HTML or SVG) or an `<area>`; none without one.
+ *
+ * @param event - the click.
+ */
+const linkHref = (event) => {
+    for (const target of event.composedPath())
+        if (target instanceof Element && (target.localName === "a" || target.localName === "area"))
+            return target.getAttribute("href") ?? target.getAttribute("xlink:href");
+    return null;
+};
+/**
+ * The address a form sent without `use:enhance` goes to: a GET form's action with its values as the search.
+ *
+ * @param form - the form.
+ * @param submitter - the button that sent it, or none.
+ * @param pageUrl - the story's page, the action's base.
+ */
+const formAddress = (form, submitter, pageUrl) => {
+    const action = new URL(submitter?.getAttribute("formaction") ?? form.getAttribute("action") ?? "", pageUrl);
+    const values = new FormData(form);
+    action.search = new URLSearchParams([...values].map(([name, value]) => [
+        name,
+        typeof value === "string" ? value : value.name
+    ])).toString();
+    return action;
+};
+/**
+ * Keeps a story in its frame: a link of the app moves the story's page, one an `hrefs` entry names calls it, one
+ * outside the app goes nowhere; a form sent without `use:enhance` is recorded, and a GET form moves the page as the
+ * browser would; each is recorded.
+ *
+ * @param canvas - the story's canvas.
+ * @param store - the story's page.
+ * @returns what stops it.
+ */
+const keepInStory = (canvas, store) => {
+    const onClick = (event) => {
+        if (event.defaultPrevented)
+            return;
+        const href = linkHref(event);
+        if (href === null)
+            return;
+        // the frame's address names the story: a link never takes the frame away from it
+        event.preventDefault();
+        store.record("link", [href]);
+        const matched = hrefCallbacksOf(store.kit.hrefs, href);
+        for (const callback of matched)
+            callback(href, event);
+        if (matched.length === 0)
+            void store.navigate("link", href);
+    };
+    const onSubmit = (event) => {
+        // `use:enhance` handles its own form first
+        if (event.defaultPrevented || !(event.target instanceof HTMLFormElement))
+            return;
+        event.preventDefault();
+        const form = event.target;
+        const method = (event.submitter?.getAttribute("formmethod") ?? form.method).toUpperCase();
+        const address = formAddress(form, event.submitter, store.page().url);
+        store.record("submit", [
+            method,
+            method === "GET" ? `${address.pathname}${address.search}` : address.pathname
+        ]);
+        if (method === "GET")
+            void store.navigate("form", address);
+    };
+    canvas.addEventListener("click", onClick);
+    canvas.addEventListener("submit", onSubmit);
+    return () => {
+        canvas.removeEventListener("click", onClick);
+        canvas.removeEventListener("submit", onSubmit);
+    };
+};
+/** The page of each story drawn now, by its parameters, and how many of its drawings use it. */
+const SHARED = new WeakMap();
+/**
+ * The page of a story about to be drawn, made the frame's current one, with its loader: the one its other drawings use
+ * when it is drawn several times at once (a matrix's cells), since one frame shows one page; a new one otherwise.
+ *
+ * @param drawing - the drawing the frame gave.
+ * @returns the page, and what lets it go when the drawing is taken away.
+ */
+const storeOf = (drawing) => {
+    const key = drawing.story.parameters;
+    const shared = SHARED.get(key);
+    const entry = shared !== undefined && shared.mounts > 0
+        ? shared
+        : { store: createKitStore(key, drawing.onEvent), mounts: 0 };
+    if (entry !== shared) {
+        entry.store.setLoader(loaderOf(entry.store.kit, entry.store));
+        SHARED.set(key, entry);
+    }
+    entry.mounts += 1;
+    setCurrentStore(entry.store);
+    return {
+        store: entry.store,
+        release: () => {
+            entry.mounts -= 1;
+        }
+    };
+};
+/** Svelte's renderer for a SvelteKit project. */
+export const kitRenderer = {
+    mount: (canvas, first, onError) => {
+        const { store, release } = storeOf(first);
+        let latest = first;
+        let inner;
+        let isGone = false;
+        const stopKeeping = keepInStory(canvas, store);
+        // an error a load throws, then or after a move, is shown in place of the story
+        store.setErrorHandler((error) => onError(toError(error)));
+        let shown = store.page();
+        // a page's component follows its data, form and params, as SvelteKit gives them again after a move or an action
+        const stopData = store.subscribe(() => {
+            const now = store.page();
+            if (now.data === shown.data && now.form === shown.form && now.params === shown.params)
+                return;
+            shown = now;
+            if (store.kit.isPage)
+                inner?.update(withPage(latest, store));
+        });
+        const draw = () => {
+            const mounted = svelteRenderer.mount(canvas, withPage(latest, store), onError);
+            inner = mounted;
+            return mounted;
+        };
+        // a page without loads is drawn at once, as any Svelte story; one with loads once they are done
+        const drawn = store.kit.loads.length === 0
+            ? draw().drawn
+            : store
+                .reload()
+                .then(async (isLoaded) => isLoaded && !isGone ? draw().drawn : new Promise(() => undefined));
+        return {
+            drawn,
+            update: (next) => {
+                latest = next;
+                inner?.update(withPage(next, store));
+            },
+            unmount: () => {
+                isGone = true;
+                stopKeeping();
+                stopData();
+                release();
+                inner?.unmount();
+            }
+        };
+    },
+    renderToString: async (drawing) => {
+        const { store, release } = storeOf(drawing);
+        try {
+            let failure;
+            store.setErrorHandler((error) => {
+                failure = error;
+            });
+            if (store.kit.loads.length > 0 && !(await store.reload()))
+                throw toError(failure);
+            return await svelteRenderer.renderToString(withPage(drawing, store));
+        }
+        finally {
+            release();
+        }
+    }
+};

package/dist/src/kitStore.d.ts

@@ -0,0 +1,90 @@
+import { type KitError, type KitNavigation, type KitPage, type NavigationType, type StoryKit } from "./kitParameters.ts";
+/** A call a story made to SvelteKit: its function (`goto`) and what it was called with. */
+export type KitCall = {
+    /** The function, as the catalogue lists it (`goto`, `invalidateAll`, `link`). */
+    readonly name: string;
+    /** What it was called with. */
+    readonly values: readonly unknown[];
+};
+/** Tells the catalogue about a call: the drawing's `onEvent`, when the catalogue gives one. */
+export type CallReport = (name: string, values: readonly unknown[]) => void;
+/** Loads the page's data for an address: the story's loads, run by the renderer. */
+export type DataLoader = (page: Pick<KitPage, "url" | "params" | "route">) => Promise<Readonly<Record<string, unknown>>>;
+/** A `beforeNavigate` callback's argument: the navigation, and how to stop it. */
+export type BeforeNavigation = KitNavigation & {
+    /** Stops the navigation. */
+    readonly cancel: () => void;
+};
+/** What a navigation gives the new page. */
+export type NavigateOptions = {
+    /** The page's new state (`App.PageState`). */
+    readonly state?: Readonly<Record<string, unknown>>;
+};
+/** A story's SvelteKit page. */
+export type KitStore = {
+    /** The story's settings. */
+    readonly kit: StoryKit;
+    /** The page, as it is now; read in an effect, the effect follows it. */
+    readonly page: () => KitPage;
+    /** The navigation under way, or the story's own; `null` when none. */
+    readonly navigating: () => Partial<KitNavigation> | null;
+    /** Whether a new version is out. */
+    readonly updated: () => boolean;
+    /** Calls a listener whenever the page changes; returns what stops it. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** Changes some of the page's fields (`form`, `status`, `error`, `state`, `data`). */
+    readonly setPage: (fields: Partial<KitPage>) => void;
+    /**
+     * Goes to an href from the page: a navigation of the app, or none for one outside it (another origin, or outside
+     * the base path), one a callback cancelled, or one a later navigation overtook.
+     *
+     * @returns whether the page moved.
+     */
+    readonly navigate: (type: NavigationType, href: string | URL, options?: NavigateOptions) => Promise<boolean>;
+    /** The data the story's loads give an href, without going there, as `preloadData` does; the page's without loads. */
+    readonly dataAt: (href: string | URL) => Promise<Readonly<Record<string, unknown>>>;
+    /**
+     * Loads the page's data again, as `invalidate` and `refreshAll` do: a redirect it throws moves the page, another
+     * error goes to the error handler.
+     *
+     * @returns whether the data was loaded.
+     */
+    readonly reload: () => Promise<boolean>;
+    /** Sets what hears an error a load threw: the frame, which shows it in place of the story. */
+    readonly setErrorHandler: (handler: ((error: unknown) => void) | undefined) => void;
+    /** Sets what loads the page's data, once the renderer has the story's loads. */
+    readonly setLoader: (loader: DataLoader | undefined) => void;
+    /** Registers a `beforeNavigate` callback; returns what removes it. */
+    readonly beforeNavigate: (callback: (navigation: BeforeNavigation) => void) => () => void;
+    /** Registers an `onNavigate` callback; returns what removes it. */
+    readonly onNavigate: (callback: (navigation: KitNavigation) => unknown) => () => void;
+    /** Registers an `afterNavigate` callback; returns what removes it. */
+    readonly afterNavigate: (callback: (navigation: KitNavigation) => void) => () => void;
+    /** The navigation `afterNavigate` sees as the page is drawn. */
+    readonly enter: () => KitNavigation;
+    /** Records a call and tells the catalogue. */
+    readonly record: (name: string, values: readonly unknown[]) => void;
+    /** The calls the story made, in order. */
+    readonly calls: () => readonly KitCall[];
+};
+/**
+ * The page's error for what a load threw: SvelteKit's `error(404, "…")` with its message, anything else as it is.
+ *
+ * @param thrown - what the load threw.
+ */
+export declare const errorOfThrown: (thrown: unknown) => KitError;
+/**
+ * A story's SvelteKit page.
+ *
+ * @param parameters - the story's parameters, which give its page.
+ * @param onEvent - tells the catalogue about each call (the drawing's `onEvent`); none outside a catalogue.
+ */
+export declare const createKitStore: (parameters: Readonly<Record<string, unknown>>, onEvent: CallReport | undefined) => KitStore;
+/**
+ * Makes a store the frame's current one: the story drawn last.
+ *
+ * @param store - the store.
+ */
+export declare const setCurrentStore: (store: KitStore) => void;
+/** The frame's current store: the story drawn last, or an idle one at `/`. */
+export declare const currentStore: () => KitStore;

package/dist/src/kitStore.js

@@ -0,0 +1,301 @@
+/**
+ * A story's SvelteKit page while it is drawn: the page its components read, where its links and `goto` calls take it,
+ * the navigation callbacks its components registered, and the calls it made, told to the catalogue.
+ *
+ * @remarks
+ * The page really moves: a link clicked in a story changes `page.url`, its route and its params (matched against the
+ * project's routes), runs `beforeNavigate`, `onNavigate` and `afterNavigate`, and loads the page's data again when the
+ * story gives a `load`. The frame's own address never changes (it names the story).
+ *
+ * Svelte follows the page through `createSubscriber`, so `$app/state` reads it with no rune of its own, and
+ * `$app/stores` subscribes to the same changes. One frame draws one story, so the store of the story drawn last is the
+ * frame's current one; it sits on a global symbol, so two copies of this module (one pre-bundled, one from the sources)
+ * share it.
+ *
+ * @module
+ */
+import { createSubscriber } from "svelte/reactivity";
+import { appSettings, pageRouteIds } from "./appSettings.js";
+import { routedPage, storyKitOf } from "./kitParameters.js";
+/**
+ * Where a page is, as a navigation names it.
+ *
+ * @param page - the page.
+ */
+const targetOf = (page) => ({
+    params: page.params,
+    route: page.route,
+    url: page.url
+});
+/** How many redirects the page's loads may throw in a row, as a browser follows them. */
+const MOST_REDIRECTS = 20;
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * The address a redirect a load threw goes to (SvelteKit's `redirect(303, "/login")`), or none.
+ *
+ * @param thrown - what the load threw.
+ */
+const redirectOf = (thrown) => isRecord(thrown) &&
+    typeof thrown["status"] === "number" &&
+    thrown["status"] >= 300 &&
+    thrown["status"] < 400 &&
+    typeof thrown["location"] === "string"
+    ? thrown["location"]
+    : undefined;
+/**
+ * The page's error for what a load threw: SvelteKit's `error(404, "…")` with its message, anything else as it is.
+ *
+ * @param thrown - what the load threw.
+ */
+export const errorOfThrown = (thrown) => {
+    if (isRecord(thrown) && isRecord(thrown["body"]) && typeof thrown["body"]["message"] === "string")
+        return { message: thrown["body"]["message"], status: statusOfThrown(thrown) };
+    return {
+        message: thrown instanceof Error ? thrown.message : String(thrown),
+        status: statusOfThrown(thrown)
+    };
+};
+/**
+ * The status of what a load threw: SvelteKit's error's, or 500.
+ *
+ * @param thrown - what the load threw.
+ */
+const statusOfThrown = (thrown) => isRecord(thrown) && typeof thrown["status"] === "number" ? thrown["status"] : 500;
+/**
+ * Whether a path is under the base path, so the app's.
+ *
+ * @param pathname - the path.
+ * @param base - the base path, or empty.
+ */
+const isInBase = (pathname, base) => base === "" || pathname === base || pathname.startsWith(`${base}/`);
+/**
+ * A navigation from a page to another, once every `beforeNavigate` callback let it start.
+ *
+ * @param type - how it started.
+ * @param from - the page it leaves.
+ * @param to - where it goes.
+ * @param before - the `beforeNavigate` callbacks.
+ * @returns the navigation and what says it is done, or none when a callback cancelled it.
+ */
+const startNavigation = (type, from, to, before) => {
+    let isCancelled = false;
+    let complete = () => undefined;
+    const navigation = {
+        from: targetOf(from),
+        to: targetOf(to),
+        type,
+        willUnload: false,
+        complete: new Promise((resolve) => {
+            complete = resolve;
+        })
+    };
+    const cancel = () => {
+        isCancelled = true;
+    };
+    for (const callback of [...before])
+        callback({ ...navigation, cancel });
+    return isCancelled ? undefined : { navigation, complete };
+};
+/**
+ * Adds a callback to a set.
+ *
+ * @param set - the set.
+ * @param callback - the callback.
+ * @returns what removes it.
+ */
+const registered = (set, callback) => {
+    set.add(callback);
+    return () => {
+        set.delete(callback);
+    };
+};
+/**
+ * A story's SvelteKit page.
+ *
+ * @param parameters - the story's parameters, which give its page.
+ * @param onEvent - tells the catalogue about each call (the drawing's `onEvent`); none outside a catalogue.
+ */
+export const createKitStore = (parameters, onEvent) => {
+    const { base } = appSettings();
+    const kit = storyKitOf(parameters, pageRouteIds(), base);
+    let page = kit.page;
+    let navigating = kit.navigating;
+    const listeners = new Set();
+    const callbacks = { before: new Set(), on: new Set(), after: new Set() };
+    const made = [];
+    let loader;
+    const changed = () => {
+        for (const listener of [...listeners])
+            listener();
+    };
+    const subscribe = (listener) => {
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    };
+    const track = createSubscriber((update) => subscribe(update));
+    /** The last navigation or reload started: one that ends after a later one started is dropped, as SvelteKit's is. */
+    let latest = 0;
+    /**
+     * What a load that threw does: a redirect moves the page (as many times as a browser follows), anything else is
+     * the page's error, shown by the catalogue.
+     *
+     * @returns whether the page moved.
+     */
+    const failed = async (thrown, redirects) => {
+        const location = redirectOf(thrown);
+        if (location !== undefined && redirects < MOST_REDIRECTS) {
+            record("redirect", [location]);
+            return navigate("goto", location, {}, redirects + 1);
+        }
+        const error = location === undefined ? thrown : new Error(`Too many redirects, the last to ${location}`);
+        page = { ...page, error: errorOfThrown(error), status: statusOfThrown(error) };
+        changed();
+        onError?.(error);
+        return false;
+    };
+    const record = (name, values) => {
+        made.push({ name, values });
+        onEvent?.(name, values);
+    };
+    let onError;
+    /** A new navigation or reload: the later one wins. */
+    const nextToken = () => {
+        latest += 1;
+        return latest;
+    };
+    /**
+     * Moves the page once its data is loaded: the `onNavigate` callbacks run, the page moves, then the `afterNavigate`
+     * ones run, what an `onNavigate` callback returned with them.
+     *
+     * @returns whether the page moved: not when a later navigation overtook this one.
+     */
+    const move = async (token, to, navigation, options) => {
+        // a load reads the address and the params, so every move loads the data again, as SvelteKit's does
+        const data = loader === undefined ? page.data : await loader(to);
+        if (token !== latest)
+            return false;
+        const returned = await Promise.all([...callbacks.on].map((callback) => callback(navigation)));
+        if (token !== latest)
+            return false;
+        page = { ...page, ...to, data, state: options.state ?? {}, form: null, error: null, status: 200 };
+        navigating = null;
+        changed();
+        for (const callback of [...callbacks.after])
+            callback(navigation);
+        for (const after of returned)
+            if (typeof after === "function")
+                Reflect.apply(after, undefined, [navigation]);
+        return true;
+    };
+    /** Goes to an href: the `beforeNavigate` callbacks may cancel it, then the page's data is loaded and it moves. */
+    const navigate = async (type, href, options = {}, redirects = 0) => {
+        const url = new URL(href, page.url);
+        // another origin, or a path outside the base path, is not the app's: SvelteKit leaves it to the browser
+        if (url.origin !== page.url.origin || !isInBase(url.pathname, base))
+            return false;
+        const to = routedPage(url, pageRouteIds(), base);
+        const started = startNavigation(type, page, to, callbacks.before);
+        if (started === undefined)
+            return false;
+        const token = nextToken();
+        navigating = started.navigation;
+        changed();
+        try {
+            return await move(token, to, started.navigation, options);
+        }
+        catch (thrown) {
+            if (token !== latest)
+                return false;
+            navigating = null;
+            changed();
+            return failed(thrown, redirects);
+        }
+        finally {
+            started.complete();
+        }
+    };
+    return {
+        kit,
+        page: () => {
+            track();
+            return page;
+        },
+        navigating: () => {
+            track();
+            return navigating;
+        },
+        updated: () => kit.updated,
+        subscribe,
+        setPage: (fields) => {
+            page = { ...page, ...fields };
+            changed();
+        },
+        navigate,
+        dataAt: async (href) => loader === undefined ? page.data : loader(routedPage(new URL(href, page.url), pageRouteIds(), base)),
+        reload: async () => {
+            if (loader === undefined)
+                return true;
+            const token = nextToken();
+            try {
+                const data = await loader(page);
+                if (token !== latest)
+                    return false;
+                page = { ...page, data };
+                changed();
+                return true;
+            }
+            catch (thrown) {
+                return token === latest ? failed(thrown, 0) : false;
+            }
+        },
+        setLoader: (next) => {
+            loader = next;
+        },
+        beforeNavigate: (callback) => registered(callbacks.before, callback),
+        onNavigate: (callback) => registered(callbacks.on, callback),
+        afterNavigate: (callback) => registered(callbacks.after, callback),
+        enter: () => ({
+            from: null,
+            to: targetOf(page),
+            type: "enter",
+            willUnload: false,
+            complete: Promise.resolve(),
+            ...kit.navigation.afterNavigate
+        }),
+        record,
+        setErrorHandler: (handler) => {
+            onError = handler;
+        },
+        calls: () => [...made]
+    };
+};
+/** Where the frame's current store is kept: one key for every copy of this module. */
+const CURRENT_KEY = Symbol.for("forgebook.sveltekit.page-store");
+/** The store a frame has before any story is drawn, and outside a catalogue: `/`, no data. */
+let idleStore;
+/**
+ * Makes a store the frame's current one: the story drawn last.
+ *
+ * @param store - the store.
+ */
+export const setCurrentStore = (store) => {
+    Reflect.set(globalThis, CURRENT_KEY, store);
+};
+/** Whether a value is a store this module made. */
+const isKitStore = (value) => typeof value === "object" &&
+    value !== null &&
+    "page" in value &&
+    typeof value.page === "function" &&
+    "navigate" in value &&
+    typeof value.navigate === "function";
+/** The frame's current store: the story drawn last, or an idle one at `/`. */
+export const currentStore = () => {
+    const store = Reflect.get(globalThis, CURRENT_KEY);
+    if (isKitStore(store))
+        return store;
+    idleStore ??= createKitStore({}, undefined);
+    return idleStore;
+};

package/dist/src/mountFrame.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The frame page of a SvelteKit catalogue: Forgebook's frame, drawing its stories with Svelte and each story's
+ * SvelteKit page. Called by the page the plugin generates from the catalogue's configuration.
+ *
+ * @module
+ */
+import { type FrameConfig } from "forgebook/frame";
+/**
+ * Shows the story the address names in the given element, drawn with Svelte for a SvelteKit project.
+ *
+ * @param container - the element the story renders into.
+ * @param config - the sources and the languages, as the shell's configuration gives them.
+ */
+export declare const mountFrame: (container: HTMLElement, config: Omit<FrameConfig, "renderer">) => Promise<void>;

package/dist/src/mountFrame.js

@@ -0,0 +1,15 @@
+/**
+ * The frame page of a SvelteKit catalogue: Forgebook's frame, drawing its stories with Svelte and each story's
+ * SvelteKit page. Called by the page the plugin generates from the catalogue's configuration.
+ *
+ * @module
+ */
+import { mountFrame as mountForgebookFrame } from "forgebook/frame";
+import { kitRenderer } from "./kitRenderer.js";
+/**
+ * Shows the story the address names in the given element, drawn with Svelte for a SvelteKit project.
+ *
+ * @param container - the element the story renders into.
+ * @param config - the sources and the languages, as the shell's configuration gives them.
+ */
+export const mountFrame = (container, config) => mountForgebookFrame(container, { ...config, renderer: kitRenderer });