storyloco 2.5.0 → 2.6.0

package/README.md

@@ -114,6 +114,19 @@ at your call site rather than move into the client.
 `client.handle_error` is on the instance, so `.catch(client.handle_error)` works without
 wrapping anything.
 
+Errors carry only a `message` by default. If your `App.Error` needs more, pass `error` to shape
+the body of every 404 and 500 storyloco raises — it's typed against your own `App.Error`:
+
+```typescript
+export const client = new StoryblokClient({
+	token: PUBLIC_STORYBLOK_ACCESS_TOKEN,
+	error: (status) => ({
+		message: status === 404 ? 'Story not found' : 'Storyblok request failed',
+		code: status === 404 ? 'NOT_FOUND' : 'STORYBLOK'
+	})
+})
+```
+
 #### 2. Use in your Svelte components
 
 **`+page.svelte`:**
@@ -252,7 +265,7 @@ const { client, version } = storyblok()
 await client.get('cdn/datasource_entries', { version })
 ```
 
-Errors go through `handle_error`, so a missing story is a 404 and anything else a 500.
+Errors go through `client.handle_error`, so a missing story is a 404 and anything else a 500, shaped by the client's `error` option.
 
 ### Use Shared Components
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "storyloco",
-	"version": "2.5.0",
+	"version": "2.6.0",
 	"description": "A collection of slick Storyblok field plugins built with Svelte 5, TypeScript, and Tailwind CSS",
 	"keywords": [
 		"storyblok",

package/packages/vite/dist/server.js

@@ -1,6 +1,6 @@
 import { getRequestEvent } from "$app/server";
 import { error } from "@sveltejs/kit";
-import { handle_error, } from "./storyblok.svelte.js";
+import {} from "./storyblok.svelte.js";
 function is_not_found(err) {
     return typeof err === "object" && err !== null && "status" in err && err.status === 404;
 }
@@ -52,7 +52,7 @@ export function setup(client) {
             .catch((err) => {
             if (is_not_found(err))
                 return null;
-            return handle_error(err);
+            return client.handle_error(err);
         });
         return (response?.data.story ?? null);
     }
@@ -60,7 +60,7 @@ export function setup(client) {
     async function story(slug, params = {}) {
         const found = await find(slug, params);
         if (!found)
-            error(404, "Story not found");
+            error(404, client.error(404));
         return found;
     }
     async function stories(params = {}) {
@@ -71,7 +71,7 @@ export function setup(client) {
             resolve_assets: 1,
             ...params,
         })
-            .catch(handle_error);
+            .catch(client.handle_error);
         return { stories: response.data.stories, total: response.total ?? 0 };
     }
     async function all(params = {}) {
@@ -83,7 +83,7 @@ export function setup(client) {
             per_page: 100,
             ...params,
         })
-            .catch(handle_error);
+            .catch(client.handle_error);
     }
     return Object.assign(context, {
         story,
@@ -97,7 +97,7 @@ export function setup(client) {
         async links(params = {}) {
             const response = await client
                 .get("cdn/links", { version: version(), per_page: 1000, ...params })
-                .catch(handle_error);
+                .catch(client.handle_error);
             return Object.values(response.data.links ?? {});
         },
     });

package/packages/vite/dist/storyblok.svelte.d.ts

@@ -43,7 +43,15 @@ export interface ClientOptions {
      * news posts reuse the blog template. Applied by `template`.
      */
     aliases?: Record<string, string>;
+    /**
+     * The body of the errors storyloco raises, for projects whose `App.Error` needs more
+     * than a message — e.g. `(status) => ({ message: "Not found", code: "NOT_FOUND" })`.
+     * `cause` is the Storyblok error, when there was one.
+     */
+    error?: ErrorBody;
 }
+/** Shapes the body of a 404 (missing story) or 500 (anything else Storyblok threw) */
+export type ErrorBody = (status: 404 | 500, cause?: unknown) => App.Error;
 /** Type alias for the storyblok api instance */
 type API = ReturnType<typeof useStoryblokApi>;
 /**
@@ -83,8 +91,10 @@ export declare class StoryblokClient {
     put: API["put"];
     /** Make a DELETE request to the Storyblok API */
     delete: API["delete"];
-    /** The standalone `handle_error`, on the instance so `.catch(client.handle_error)` works */
-    handle_error: typeof handle_error;
+    /** Shapes the body of every error storyloco raises; see `ClientOptions.error` */
+    error: ErrorBody;
+    /** `handle_error` with this client's `error` shape, bound so `.catch(client.handle_error)` works */
+    handle_error: (err: unknown) => never;
     /**
      * Configured here rather than by subclassing, so setup is one expression.
      *
@@ -97,7 +107,7 @@ export declare class StoryblokClient {
      * })
      * ```
      */
-    constructor({ token, components, relations, aliases }: ClientOptions);
+    constructor({ token, components, relations, aliases, error, }: ClientOptions);
     /**
      * Load the components and set up the SDK.
      *
@@ -215,9 +225,10 @@ export declare function href(link?: Link): string | undefined;
  * Turn a Storyblok error into a SvelteKit one, for `.catch(handle_error)`.
  *
  * A missing story is a 404; anything else is a 500, since the CMS being unreachable isn't
- * something to show a visitor a Storyblok status code for.
+ * something to show a visitor a Storyblok status code for. `body` shapes the error; prefer
+ * `client.handle_error`, which passes the client's own.
  */
-export declare function handle_error(err: unknown): never;
+export declare function handle_error(err: unknown, body?: ErrorBody): never;
 /** Declaring these keeps `SbBlokData`'s index signature from widening every access. */
 interface BlokFields {
     anchor?: string;

package/packages/vite/dist/storyblok.svelte.js

@@ -2,6 +2,9 @@ import { storyblokInit, apiPlugin, renderRichText as richtext, useStoryblokBridg
 import { SvelteMap } from "svelte/reactivity";
 import { createAttachmentKey as attach } from "svelte/attachments";
 import { error } from "@sveltejs/kit";
+const default_error = (status) => ({
+    message: status === 404 ? "Story not found" : "Internal server error",
+});
 /**
  * Main Storyblok client class that handles component registration, API calls, and story bridging
  * Provides a unified interface for working with Storyblok in Svelte applications
@@ -56,8 +59,10 @@ export class StoryblokClient {
     put = async (...args) => (await this.#api()).put(...args);
     /** Make a DELETE request to the Storyblok API */
     delete = async (...args) => (await this.#api()).delete(...args);
-    /** The standalone `handle_error`, on the instance so `.catch(client.handle_error)` works */
-    handle_error = handle_error;
+    /** Shapes the body of every error storyloco raises; see `ClientOptions.error` */
+    error = default_error;
+    /** `handle_error` with this client's `error` shape, bound so `.catch(client.handle_error)` works */
+    handle_error = (err) => handle_error(err, this.error);
     /**
      * Configured here rather than by subclassing, so setup is one expression.
      *
@@ -70,11 +75,12 @@ export class StoryblokClient {
      * })
      * ```
      */
-    constructor({ token, components = {}, relations = [], aliases = {} }) {
+    constructor({ token, components = {}, relations = [], aliases = {}, error = default_error, }) {
         this.#access_token = token;
         this.#component_imports = components;
         this.relations = relations;
         this.aliases = aliases;
+        this.error = error;
         // Eager, but handled so a failure surfaces to whoever awaits `init` rather than
         // as an unhandled rejection
         this.init().catch(() => { });
@@ -166,14 +172,15 @@ export function href(link) {
  * Turn a Storyblok error into a SvelteKit one, for `.catch(handle_error)`.
  *
  * A missing story is a 404; anything else is a 500, since the CMS being unreachable isn't
- * something to show a visitor a Storyblok status code for.
+ * something to show a visitor a Storyblok status code for. `body` shapes the error; prefer
+ * `client.handle_error`, which passes the client's own.
  */
-export function handle_error(err) {
+export function handle_error(err, body = default_error) {
     console.error(err);
     const status = typeof err === "object" && err !== null && "status" in err ? err.status : undefined;
     if (status === 404)
-        error(404, "Story not found");
-    error(500, "Internal server error");
+        error(404, body(404, err));
+    error(500, body(500, err));
 }
 /**
  * Spread onto a block's root element to wire it up for the visual editor.