@deepsel/cms-utils 1.1.3 → 1.1.5

package/dist/blog/fetchBlogList.d.ts

@@ -0,0 +1,15 @@
+import type { BlogListData } from './types';
+import type { Pagination } from '../page/getPathType';
+interface FetchBlogListProps {
+    lang?: string;
+    pagination?: Pagination;
+    astroRequest?: Request;
+    authToken?: string;
+    backendHost?: string;
+}
+/**
+ * Fetches blog list from the backend by language
+ * Corresponds to GET /blog_post/website/{lang}
+ */
+export declare function fetchBlogList({ astroRequest, pagination, authToken, lang, backendHost, }: FetchBlogListProps): Promise<BlogListData>;
+export {};

package/dist/blog/fetchBlogList.js

@@ -0,0 +1,51 @@
+/**
+ * Fetches blog list from the backend by language
+ * Corresponds to GET /blog_post/website/{lang}
+ */
+export async function fetchBlogList({ astroRequest, pagination, authToken, lang = 'default', backendHost = 'http://localhost:8000/api/v1', }) {
+    try {
+        let url = `${backendHost}/blog_post/list/${lang}`;
+        if (pagination) {
+            const searchParams = new URLSearchParams();
+            if (pagination.page)
+                searchParams.append('page', pagination.page.toString());
+            if (pagination.pageSize)
+                searchParams.append('page_size', pagination.pageSize.toString());
+            url += `?${searchParams.toString()}`;
+        }
+        const fetchOptions = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        let hostname = null;
+        if (astroRequest) {
+            const url = new URL(astroRequest.url);
+            hostname = url.hostname;
+        }
+        else if (typeof window !== 'undefined') {
+            hostname = window.location.hostname;
+        }
+        if (hostname) {
+            fetchOptions.headers['X-Original-Host'] = hostname;
+            fetchOptions.headers['X-Frontend-Host'] = hostname;
+        }
+        if (authToken) {
+            fetchOptions.headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 401) {
+            throw new Error('Authentication required');
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to fetch blog list: ${response.statusText}`);
+        }
+        const jsonData = await response.json();
+        return jsonData;
+    }
+    catch (error) {
+        console.error('Error fetching blog list:', error);
+        throw error;
+    }
+}

package/dist/blog/fetchBlogPost.d.ts

@@ -0,0 +1,14 @@
+import type { BlogPostData } from './types';
+interface FetchBlogPostProps {
+    path: string;
+    lang?: string;
+    astroRequest?: Request;
+    authToken?: string;
+    backendHost?: string;
+}
+/**
+ * Fetches a single blog post from the backend by language and path
+ * Corresponds to GET /blog_post/website/{lang}/{path}
+ */
+export declare function fetchBlogPost({ path, lang, astroRequest, authToken, backendHost, }: FetchBlogPostProps): Promise<BlogPostData>;
+export {};

package/dist/blog/fetchBlogPost.js

@@ -0,0 +1,61 @@
+import { fetchPublicSettings } from '../page';
+/**
+ * Fetches a single blog post from the backend by language and path
+ * Corresponds to GET /blog_post/website/{lang}/{path}
+ */
+export async function fetchBlogPost({ path, lang = 'default', astroRequest, authToken, backendHost = 'http://localhost:8000/api/v1', }) {
+    try {
+        const cleanPath = path.startsWith('/') ? path.substring(1) : path;
+        let postSlug = cleanPath;
+        // rm the blog/ prefix
+        if (cleanPath.startsWith('blog/')) {
+            postSlug = cleanPath.substring('blog/'.length);
+        }
+        const url = `${backendHost}/blog_post/single/${lang}/${postSlug}`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        let hostname = null;
+        if (astroRequest) {
+            const url = new URL(astroRequest.url);
+            hostname = url.hostname;
+        }
+        else if (typeof window !== 'undefined') {
+            hostname = window.location.hostname;
+        }
+        if (hostname) {
+            fetchOptions.headers['X-Original-Host'] = hostname;
+            fetchOptions.headers['X-Frontend-Host'] = hostname;
+        }
+        if (authToken) {
+            fetchOptions.headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 401) {
+            throw new Error('Authentication required');
+        }
+        if (response.status === 404) {
+            try {
+                const { detail } = (await response.json());
+                console.warn('404', url, { detail });
+            }
+            catch {
+                console.warn('404', url);
+            }
+            const siteSettings = await fetchPublicSettings(null, astroRequest, lang, backendHost);
+            return {
+                notFound: true,
+                public_settings: siteSettings,
+            };
+        }
+        const jsonData = await response.json();
+        return jsonData;
+    }
+    catch (error) {
+        console.error('Error fetching blog post:', error);
+        throw error;
+    }
+}

package/dist/blog/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetchBlogList';
+export * from './fetchBlogPost';
+export * from './types';

package/dist/blog/index.js

@@ -0,0 +1,3 @@
+export * from './fetchBlogList';
+export * from './fetchBlogPost';
+export * from './types';

package/dist/blog/types.d.ts

@@ -0,0 +1,45 @@
+import type { SiteSettings } from '../types';
+import type { SeoMetadata, LanguageAlternative } from '../page/types';
+export interface BlogPostAuthor {
+    id: number;
+    display_name?: string;
+    username: string;
+    image?: string;
+}
+export interface BlogPostListItem {
+    id: number;
+    title: string;
+    slug: string;
+    excerpt?: string;
+    featured_image_id?: number;
+    featured_image_name?: string;
+    publish_date?: string;
+    author?: BlogPostAuthor;
+    lang: string;
+}
+export interface BlogListData {
+    lang: string;
+    public_settings: SiteSettings;
+    blog_posts: BlogPostListItem[];
+    page: number;
+    page_size: number;
+    total_count: number;
+    total_pages: number;
+}
+export interface BlogPostData {
+    id?: number;
+    title?: string;
+    content?: string;
+    lang?: string;
+    public_settings: SiteSettings;
+    seo_metadata?: SeoMetadata;
+    custom_code?: string | null;
+    page_custom_code?: string | null;
+    require_login?: boolean | null;
+    featured_image_id?: number | null;
+    featured_image_name?: string | null;
+    publish_date?: string | null;
+    author?: BlogPostAuthor | null;
+    language_alternatives?: LanguageAlternative[];
+    notFound?: boolean;
+}

package/dist/blog/types.js

@@ -0,0 +1 @@
+export {};

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './websiteDataTypes';

package/dist/constants/index.js

@@ -0,0 +1 @@
+export * from './websiteDataTypes';

package/dist/constants/websiteDataTypes.d.ts

@@ -0,0 +1,7 @@
+export declare const WebsiteDataTypes: {
+    readonly Page: "Page";
+    readonly BlogList: "BlogList";
+    readonly BlogPost: "BlogPost";
+    readonly SearchResults: "SearchResults";
+};
+export type WebsiteDataType = (typeof WebsiteDataTypes)[keyof typeof WebsiteDataTypes];

package/dist/constants/websiteDataTypes.js

@@ -0,0 +1,6 @@
+export const WebsiteDataTypes = {
+    Page: 'Page',
+    BlogList: 'BlogList',
+    BlogPost: 'BlogPost',
+    SearchResults: 'SearchResults',
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './page';
-export * from './language';
 export * from './menus';
+export * from './blog';
 export * from './types';
+export * from './constants';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './page';
-export * from './language';
 export * from './menus';
+export * from './blog';
 export * from './types';
+export * from './constants';

package/dist/menus/isActiveMenu.d.ts

@@ -1,3 +1,3 @@
 import type { MenuItem } from './types';
-import type { PageData } from '../page';
-export declare const isActiveMenu: (menuItem: MenuItem, pageData: PageData) => boolean;
+import type { WebsiteData } from '../types';
+export declare const isActiveMenu: (menuItem: MenuItem, websiteData: WebsiteData) => boolean;

package/dist/menus/isActiveMenu.js

@@ -1,11 +1,11 @@
 // Check if a menu item should be marked as active
-export const isActiveMenu = (menuItem, pageData) => {
+export const isActiveMenu = (menuItem, websiteData) => {
     // return if not browser
     if (typeof window === 'undefined') {
         return false;
     }
     const location = window.location;
-    const currentLang = pageData.lang;
+    const currentLang = websiteData.data.lang;
     let result;
     if (menuItem.url === '/') {
         result =

package/dist/page/fetchPageData.d.ts

@@ -1,5 +1,13 @@
 import type { PageData } from './types';
+interface FetchPageDataProps {
+    path: string;
+    lang?: string;
+    astroRequest?: Request;
+    authToken?: string;
+    backendHost?: string;
+}
 /**
  * Fetches page data from the backend by language and slug
  */
-export declare function fetchPageData(lang: string | null, slug: string, isPreview?: boolean, authToken?: string | null, astroRequest?: Request | null, backendHost?: string): Promise<PageData>;
+export declare function fetchPageData({ path, lang, astroRequest, authToken, backendHost, }: FetchPageDataProps): Promise<PageData>;
+export {};

package/dist/page/fetchPageData.js

@@ -2,25 +2,23 @@ import { fetchPublicSettings } from './fetchPublicSettings';
 /**
  * Fetches page data from the backend by language and slug
  */
-export async function fetchPageData(lang, slug, isPreview = false, authToken = null, astroRequest = null, backendHost = 'http://localhost:8000') {
+export async function fetchPageData({ path, lang, astroRequest, authToken, backendHost = 'http://localhost:8000/api/v1', }) {
     try {
-        // Format the slug properly, make sure it starts with a slash
-        let formattedSlug = slug.startsWith('/') ? slug : `/${slug}`;
+        // Format the path properly, make sure it starts with a slash
+        let formattedPath = path.startsWith('/') ? path : `/${path}`;
         // Backend will consider 'default' as the home slug
-        if (formattedSlug === '/') {
-            formattedSlug = '/default';
+        if (formattedPath === '/') {
+            formattedPath = '/default';
         }
         // Determine the URL based on whether a language is provided
-        let url;
-        if (lang && lang !== 'default') {
-            url = `${backendHost}/page/website/${lang}${formattedSlug}`;
-        }
-        else {
-            url = `${backendHost}/page/website/default${formattedSlug}`;
-        }
+        const langPrefix = lang || 'default';
+        let url = `${backendHost}/page/website/${langPrefix}${formattedPath}`;
         // Add preview parameter if enabled
-        if (isPreview) {
-            url += '?preview=true';
+        if (astroRequest) {
+            const previewParam = new URL(astroRequest.url).searchParams.get('preview');
+            if (previewParam === 'true') {
+                url += `?preview=true`;
+            }
         }
         // Prepare fetch options
         const fetchOptions = {
@@ -33,8 +31,8 @@ export async function fetchPageData(lang, slug, isPreview = false, authToken = n
         let hostname = null;
         // Server-side: Extract hostname from Astro request
         if (astroRequest) {
-            const url = new URL(astroRequest.url);
-            hostname = url.hostname;
+            const requestUrl = new URL(astroRequest.url);
+            hostname = requestUrl.hostname;
         }
         // Client-side: Extract hostname from window
         else if (typeof window !== 'undefined') {
@@ -57,22 +55,24 @@ export async function fetchPageData(lang, slug, isPreview = false, authToken = n
         }
         // Only treat actual 404 as not found
         if (response.status === 404) {
-            const { detail } = await response.json();
-            console.warn('404', url, { detail });
+            try {
+                const { detail } = await response.json();
+                console.warn('404', url, { detail });
+            }
+            catch {
+                console.warn('404', url);
+            }
             // When page is not found, still fetch menus and site settings
             try {
                 const siteSettings = await fetchPublicSettings(null, astroRequest, lang, backendHost);
                 return {
                     notFound: true,
-                    status: 404,
-                    detail,
                     public_settings: siteSettings,
-                    lang: lang || siteSettings.default_language?.iso_code || 'en',
                 };
             }
             catch (settingsError) {
                 console.warn('Could not fetch site settings for 404 page:', settingsError);
-                throw new Error(`Page not found: ${detail}`);
+                throw new Error(`Page not found`);
             }
         }
         try {

package/dist/page/fetchSearchResults.d.ts

@@ -0,0 +1,31 @@
+import type { SiteSettings } from '../types';
+export interface SearchResultItem {
+    id: string;
+    title: string;
+    url: string;
+    publishDate: string | null;
+    contentType: string;
+    relevanceScore: number;
+}
+export interface SearchResultsData {
+    lang: string;
+    query: string;
+    public_settings: SiteSettings;
+    results: SearchResultItem[];
+    total: number;
+    suggestions: string[];
+}
+interface FetchSearchResultsProps {
+    lang?: string;
+    q: string;
+    limit?: number;
+    astroRequest?: Request;
+    authToken?: string;
+    backendHost?: string;
+}
+/**
+ * Fetches search results from the backend.
+ * Calls GET /api/v1/page/website_search/{lang}?q=...&limit=...
+ */
+export declare function fetchSearchResults({ lang, q, limit, astroRequest, authToken, backendHost, }: FetchSearchResultsProps): Promise<SearchResultsData>;
+export {};

package/dist/page/fetchSearchResults.js

@@ -0,0 +1,73 @@
+import { fetchPublicSettings } from './fetchPublicSettings';
+/**
+ * Fetches search results from the backend.
+ * Calls GET /api/v1/page/website_search/{lang}?q=...&limit=...
+ */
+export async function fetchSearchResults({ lang = 'default', q, limit = 100, astroRequest, authToken, backendHost = 'http://localhost:8000/api/v1', }) {
+    // Build hostname for headers
+    let hostname = null;
+    if (astroRequest) {
+        const requestUrl = new URL(astroRequest.url);
+        hostname = requestUrl.hostname;
+    }
+    else if (typeof window !== 'undefined') {
+        hostname = window.location.hostname;
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (hostname) {
+        headers['X-Original-Host'] = hostname;
+        headers['X-Frontend-Host'] = hostname;
+    }
+    if (authToken) {
+        headers['Authorization'] = `Bearer ${authToken}`;
+    }
+    // Always fetch public_settings alongside the search call
+    const settingsPromise = fetchPublicSettings(null, astroRequest ?? null, lang, `http://localhost:8000`);
+    // If no query, skip the search call and return empty results
+    if (!q.trim()) {
+        const public_settings = await settingsPromise;
+        // Normalize lang: replace 'default' with the actual ISO code from settings
+        const resolvedLang = lang === 'default' ? public_settings.default_language?.iso_code || lang : lang;
+        return {
+            lang: resolvedLang,
+            query: q,
+            public_settings,
+            results: [],
+            total: 0,
+            suggestions: [],
+        };
+    }
+    const searchParams = new URLSearchParams({ q, limit: String(limit) });
+    const searchUrl = `${backendHost}/page/website_search/${lang}?${searchParams.toString()}`;
+    const [public_settings, searchResponse] = await Promise.allSettled([
+        settingsPromise,
+        fetch(searchUrl, { method: 'GET', headers }),
+    ]);
+    const resolvedSettings = public_settings.status === 'fulfilled' ? public_settings.value : {};
+    // Normalize lang: replace 'default' with the actual ISO code from settings
+    const resolvedLang = lang === 'default' ? resolvedSettings.default_language?.iso_code || lang : lang;
+    if (searchResponse.status === 'rejected' || !searchResponse.value.ok) {
+        console.error('Error fetching search results:', searchResponse.status === 'rejected'
+            ? searchResponse.reason
+            : searchResponse.value.statusText);
+        return {
+            lang: resolvedLang,
+            query: q,
+            public_settings: resolvedSettings,
+            results: [],
+            total: 0,
+            suggestions: [],
+        };
+    }
+    const apiData = await searchResponse.value.json();
+    return {
+        lang: resolvedLang,
+        query: q,
+        public_settings: resolvedSettings,
+        results: apiData.results ?? [],
+        total: apiData.total ?? 0,
+        suggestions: apiData.suggestions ?? [],
+    };
+}

package/dist/page/getPathType.d.ts

@@ -0,0 +1,9 @@
+import { type WebsiteDataType } from '../constants';
+export interface Pagination {
+    page?: number;
+    pageSize?: number;
+}
+export declare function getPathType(path: string): {
+    pathType: WebsiteDataType;
+    pagination?: Pagination;
+};

package/dist/page/getPathType.js

@@ -0,0 +1,46 @@
+import { WebsiteDataTypes } from '../constants';
+export function getPathType(path) {
+    let pathType = WebsiteDataTypes.Page;
+    let pagination = undefined;
+    // delete forward at the beginning
+    if (path.startsWith('/')) {
+        path = path.slice(1);
+    }
+    if (path === 'search' || path.startsWith('search?') || path.startsWith('search/')) {
+        return { pathType: WebsiteDataTypes.SearchResults };
+    }
+    if (path.startsWith('blog')) {
+        // split
+        const parts = path.split('/');
+        let pageSize = undefined;
+        // extract query parameters if any
+        const queryString = path.split('?')[1];
+        if (queryString) {
+            const params = new URLSearchParams(queryString);
+            const size = params.get('pageSize');
+            if (size && !isNaN(Number(size))) {
+                pageSize = Number(size);
+            }
+        }
+        // check which blog list format, either /blog, /blog/page/2, or /blog/{slug}
+        if (parts.length > 1 && parts[1] !== '') {
+            // /blog/page/2
+            if (parts[1] === 'page' && parts[2] && !isNaN(Number(parts[2]))) {
+                pathType = WebsiteDataTypes.BlogList;
+                pagination = { page: Number(parts[2]), pageSize };
+            }
+            // /blog/{slug}
+            else {
+                pathType = WebsiteDataTypes.BlogPost;
+            }
+        }
+        else {
+            // /blog
+            pathType = WebsiteDataTypes.BlogList;
+            if (pageSize) {
+                pagination = { pageSize };
+            }
+        }
+    }
+    return { pathType, pagination };
+}

package/dist/page/index.d.ts

@@ -1,6 +1,7 @@
-export * from './fetchFormData';
 export * from './fetchPageData';
 export * from './fetchPublicSettings';
+export * from './fetchSearchResults';
 export * from './getAuthToken';
-export * from './parseSlugForLangAndPath';
+export * from './parseSlug';
 export * from './types';
+export * from './isCrossingTemplateBoundary';

package/dist/page/index.js

@@ -1,6 +1,7 @@
-export * from './fetchFormData';
 export * from './fetchPageData';
 export * from './fetchPublicSettings';
+export * from './fetchSearchResults';
 export * from './getAuthToken';
-export * from './parseSlugForLangAndPath';
+export * from './parseSlug';
 export * from './types';
+export * from './isCrossingTemplateBoundary';

package/dist/page/isCrossingTemplateBoundary.d.ts

@@ -0,0 +1 @@
+export declare const isCrossingTemplateBoundary: (fromPath: string, toPath: string) => boolean;

package/dist/page/isCrossingTemplateBoundary.js

@@ -0,0 +1,6 @@
+import { getPathType } from './getPathType';
+export const isCrossingTemplateBoundary = (fromPath, toPath) => {
+    const fromPathType = getPathType(fromPath).pathType;
+    const toPathType = getPathType(toPath).pathType;
+    return fromPathType !== toPathType;
+};

package/dist/page/parseSlug.d.ts

@@ -0,0 +1,12 @@
+import type { Pagination } from './getPathType';
+import type { WebsiteDataType } from '../constants';
+export interface SlugParseResult {
+    lang?: string;
+    path: string;
+    pathType: WebsiteDataType;
+    pagination?: Pagination;
+}
+/**
+ * Parses a slug to determine language and path
+ */
+export declare function parseSlug(slug: string | null): SlugParseResult;

package/dist/page/{parseSlugForLangAndPath.js → parseSlug.js}

@@ -1,10 +1,11 @@
-import { isValidLanguageCode } from '../language';
+import { isValidLanguageCode } from './isValidLanguageCode';
+import { getPathType } from './getPathType';
 /**
  * Parses a slug to determine language and path
  */
-export function parseSlugForLangAndPath(slug) {
+export function parseSlug(slug) {
     const slugParts = slug ? slug.split('/').filter(Boolean) : [];
-    let lang = null;
+    let lang;
     let path = '/';
     // Check if the first part is a valid language code
     if (slugParts.length > 0 && isValidLanguageCode(slugParts[0])) {
@@ -15,8 +16,9 @@ export function parseSlugForLangAndPath(slug) {
         }
     }
     else {
-        // No language in URL, use the path as is with a leading slash
-        path = slugParts.length > 0 ? '/' + slugParts.join('/') : '/';
+        // No language in URL, use the path as is
+        path = slugParts.length > 0 ? slugParts.join('/') : '/';
     }
-    return { lang, path };
+    const { pathType, pagination } = getPathType(path);
+    return { lang, path, pathType, pagination };
 }

package/dist/page/types.d.ts

@@ -1,9 +1,5 @@
 import type { SiteSettings } from '../types';
 import type { MenuItem } from '../menus/types';
-export interface SlugParseResult {
-    lang: string | null;
-    path: string;
-}
 export interface Language {
     id: number;
     name: string;
@@ -35,41 +31,17 @@ export interface LanguageAlternative {
     slug: string;
     locale: Language;
 }
-export interface BlogPostAuthor {
-    id: number;
-    display_name?: string;
-    username: string;
-    image?: string;
-}
-export interface BlogPostListItem {
-    id: number;
-    title: string;
-    slug: string;
-    excerpt?: string;
-    featured_image_id?: number;
-    publish_date?: string;
-    author?: BlogPostAuthor;
-    lang: string;
-}
 export interface PageData {
     id?: number;
     title?: string;
     content?: Content;
-    lang: string;
+    slug?: string;
+    lang?: string;
     public_settings: SiteSettings;
     seo_metadata?: SeoMetadata;
     language_alternatives?: LanguageAlternative[];
-    is_frontend_page?: boolean | null;
-    string_id?: string | null;
-    contents?: unknown;
     page_custom_code?: string | null;
     custom_code?: string | null;
     require_login?: boolean;
-    blog_posts?: BlogPostListItem[];
-    featured_image_id?: number;
-    publish_date?: string;
-    author?: BlogPostAuthor;
     notFound?: boolean;
-    status?: number;
-    detail?: string;
 }

package/dist/types.d.ts

@@ -1,5 +1,13 @@
 import type { MenuItem } from './menus/types';
 import type { SpecialTemplate } from './page/types';
+import type { WebsiteDataType } from './constants';
+import type { PageData, SearchResultsData } from './page';
+import type { BlogListData, BlogPostData } from './blog';
+export type WebsiteData = {
+    type: WebsiteDataType;
+    data: PageData | BlogListData | BlogPostData | SearchResultsData;
+    settings?: SiteSettings;
+};
 export interface SiteSettings {
     id: number;
     name: string;

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@deepsel/cms-utils",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Helper utilities for Deepsel CMS",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DeepselSystems/deepsel-cms",
+    "directory": "packages/cms-utils"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -20,70 +25,6 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    },
-    "./types": {
-      "import": "./dist/types.js",
-      "types": "./dist/types.d.ts"
-    },
-    "./language": {
-      "import": "./dist/language/index.js",
-      "types": "./dist/language/index.d.ts"
-    },
-    "./language/isValidLanguageCode": {
-      "import": "./dist/language/isValidLanguageCode.js",
-      "types": "./dist/language/isValidLanguageCode.d.ts"
-    },
-    "./menus": {
-      "import": "./dist/menus/index.js",
-      "types": "./dist/menus/index.d.ts"
-    },
-    "./menus/isActiveMenu": {
-      "import": "./dist/menus/isActiveMenu.js",
-      "types": "./dist/menus/isActiveMenu.d.ts"
-    },
-    "./menus/types": {
-      "import": "./dist/menus/types.js",
-      "types": "./dist/menus/types.d.ts"
-    },
-    "./page": {
-      "import": "./dist/page/index.js",
-      "types": "./dist/page/index.d.ts"
-    },
-    "./page/constants": {
-      "import": "./dist/page/constants.js",
-      "types": "./dist/page/constants.d.ts"
-    },
-    "./page/types": {
-      "import": "./dist/page/types.js",
-      "types": "./dist/page/types.d.ts"
-    },
-    "./page/fetchBlogListData": {
-      "import": "./dist/page/fetchBlogListData.js",
-      "types": "./dist/page/fetchBlogListData.d.ts"
-    },
-    "./page/fetchBlogPostData": {
-      "import": "./dist/page/fetchBlogPostData.js",
-      "types": "./dist/page/fetchBlogPostData.d.ts"
-    },
-    "./page/fetchFormData": {
-      "import": "./dist/page/fetchFormData.js",
-      "types": "./dist/page/fetchFormData.d.ts"
-    },
-    "./page/fetchPageData": {
-      "import": "./dist/page/fetchPageData.js",
-      "types": "./dist/page/fetchPageData.d.ts"
-    },
-    "./page/fetchPublicSettings": {
-      "import": "./dist/page/fetchPublicSettings.js",
-      "types": "./dist/page/fetchPublicSettings.d.ts"
-    },
-    "./page/getAuthToken": {
-      "import": "./dist/page/getAuthToken.js",
-      "types": "./dist/page/getAuthToken.d.ts"
-    },
-    "./page/parseSlugForLangAndPath": {
-      "import": "./dist/page/parseSlugForLangAndPath.js",
-      "types": "./dist/page/parseSlugForLangAndPath.d.ts"
     }
   },
   "files": [

package/dist/language/index.d.ts

@@ -1 +0,0 @@
-export * from './isValidLanguageCode';

package/dist/language/index.js

@@ -1 +0,0 @@
-export * from './isValidLanguageCode';

package/dist/page/constants.js

@@ -1 +0,0 @@
-"use strict";

package/dist/page/fetchFormData.d.ts

@@ -1,4 +0,0 @@
-/**
- * Fetches Form data from the backend by language and slug
- */
-export declare function fetchFormData(lang: string, slug: string, backendHost?: string): Promise<Record<string, unknown>>;

package/dist/page/fetchFormData.js

@@ -1,38 +0,0 @@
-/**
- * Fetches Form data from the backend by language and slug
- */
-export async function fetchFormData(lang, slug, backendHost = 'http://localhost:8000') {
-    try {
-        // Format the slug properly
-        const formattedSlug = slug.replace(/^\/forms\//, '');
-        // Determine the URL based on whether a language is provided
-        const url = `${backendHost}/form/website/${lang}/${formattedSlug}`;
-        // Prepare fetch options
-        const fetchOptions = {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        };
-        // Fetch the page data from the backend
-        const response = await fetch(url, fetchOptions);
-        // Only treat actual 404 as not found
-        if (response.status === 404) {
-            const { detail } = await response.json();
-            console.warn('404', url, { detail });
-            return { notFound: true, status: 404, detail };
-        }
-        try {
-            // Parse the JSON
-            return await response.json();
-        }
-        catch (parseError) {
-            console.error(`Failed to parse response: ${parseError.message}`);
-            return { error: true, parseError: parseError.message };
-        }
-    }
-    catch (error) {
-        console.error('Error fetching page data:', error);
-        return { error: true, message: error.message };
-    }
-}

package/dist/page/parseSlugForLangAndPath.d.ts

@@ -1,5 +0,0 @@
-import type { SlugParseResult } from './types';
-/**
- * Parses a slug to determine language and path
- */
-export declare function parseSlugForLangAndPath(slug: string | null): SlugParseResult;