@deepsel/cms-utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Deepsel Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @deepsel/cms-utils
+
+A collection of light-weight helper functions for building DeepCMS features in JavaScript/TypeScript apps.
+
+`@deepsel/cms-utils` is designed to be:
+
+- **Framework-agnostic** – works with Node, React, Astro, Next.js, etc.
+- **TypeScript-friendly** – fully typed helpers.
+- **CMS-oriented** – utilities for menus, slugs, URLs, localization, content trees, etc.
+
+---
+
+## Installation
+
+```bash
+npm install @deepsel/cms-utils
+```
+
+## Basic Usage
+
+Example (TypeScript / ESM):
+
+```typescript
+import { getMenusForCurrentLang } from '@deepsel/cms-utils';
+
+const menus = getMenusForCurrentLang();
+
+console.log(menus);
+```
+
+## Local Development
+
+This section explains how to develop `@deepsel/cms-utils` and use new, unpublished features in your app locally, using a local file dependency.
+
+### 1. Folder Layout
+
+Clone this repo in your workspace:
+
+```
+git clone git@github.com:DeepselSystems/cms-utils.git
+```
+
+Put your package and your app side by side:
+
+```
+workspace/
+├─ cms-utils/    # this repo (@deepsel/cms-utils)
+└─ my-app/       # your actual app that consumes it
+```
+
+- `cms-utils/` → the npm package repo (this one).
+- `my-app/` → any app (React, Vue, Next.js, Astro, etc.) that will import `@deepsel/cms-utils`.
+
+### 2. Configure your App to Use the local package
+
+In `my-app/package.json`, point the dependency to the local folder:
+
+```json
+{
+  "dependencies": {
+    "@deepsel/cms-utils": "file:../cms-utils"
+  }
+}
+```
+
+Then, in `my-app`, run
+
+```bash
+npm install
+```
+
+What this does:
+
+- Creates a symlink in `my-app/node_modules/@deepsel/cms-utils` that points to `../cms-utils`.
+- The app will now use the local source rather than a published version from npm.
+
+### 3. Build the Package in Watch Mode
+
+In `cms-utils`, run
+
+```bash
+npm install    # first time only
+npm run dev    # tsc --watch, keeps dist/ in sync with src/
+```
+
+### 4. Use the Package in the App During Development
+
+In your app (`my-app`), import from `@deepsel/cms-utils` as if it were a regular npm package:
+
+```typescript
+// inside my-app
+import { getMenusForCurrentLang } from '@deepsel/cms-utils';
+
+const menus = getMenusForCurrentLang();
+```
+
+### 5. Build the Package for Production
+
+Once you’re happy with a set of changes, open a PR to merge them into the main branch.
+Then you can update your app to use the published version:
+
+```json
+{
+  "dependencies": {
+    "@deepsel/cms-utils": "^1.0.0"
+  }
+}
+```
+
+## License
+
+MIT – feel free to use in your own projects.

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/language/index.d.ts

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

package/dist/language/index.js

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

package/dist/language/isValidLanguageCode.d.ts

@@ -0,0 +1,5 @@
+export declare const validLanguageCodes: string[];
+/**
+ * Checks if a string is a valid language code
+ */
+export declare function isValidLanguageCode(lang: string): boolean;

package/dist/language/isValidLanguageCode.js

@@ -0,0 +1,98 @@
+export const validLanguageCodes = [
+    'am_ET',
+    'ar',
+    'ar_SY',
+    'az',
+    'bg',
+    'bn_IN',
+    'bs',
+    'ca_ES',
+    'cs_CZ',
+    'da_DK',
+    'de',
+    'de_CH',
+    'el_GR',
+    'en',
+    'en_AU',
+    'en_CA',
+    'en_GB',
+    'en_IN',
+    'en_NZ',
+    'er',
+    'es',
+    'es_419',
+    'es_AR',
+    'es_BO',
+    'es_CL',
+    'es_CO',
+    'es_CR',
+    'es_DO',
+    'es_EC',
+    'es_GT',
+    'es_MX',
+    'es_PA',
+    'es_PE',
+    'es_PY',
+    'es_UY',
+    'es_VE',
+    'et',
+    'eu_ES',
+    'fa',
+    'fi',
+    'fr',
+    'fr_BE',
+    'fr_CA',
+    'fr_CH',
+    'gl',
+    'gu',
+    'hi',
+    'hr',
+    'hu',
+    'id',
+    'it',
+    'ja',
+    'ka',
+    'kab',
+    'km',
+    'ko_KP',
+    'ko_KR',
+    'lb',
+    'lo',
+    'lt',
+    'lv',
+    'mk',
+    'ml',
+    'mn',
+    'ms',
+    'my',
+    'nb_NO',
+    'nl',
+    'nl_BE',
+    'pl',
+    'pt',
+    'pt_AO',
+    'pt_BR',
+    'ro',
+    'ru',
+    'sk',
+    'sl',
+    'sq',
+    'sr@latin',
+    'sr_RS',
+    'sv',
+    'te',
+    'th',
+    'tl',
+    'tr',
+    'uk',
+    'vi',
+    'zh_CN',
+    'zh_HK',
+    'zh_TW',
+];
+/**
+ * Checks if a string is a valid language code
+ */
+export function isValidLanguageCode(lang) {
+    return validLanguageCodes.includes(lang);
+}

package/dist/menus/getCurrentLangMenus.d.ts

@@ -0,0 +1,3 @@
+import { ProcessedMenuItem } from './types';
+import type { SiteSettings } from '../types';
+export declare const getCurrentLangMenus: (settings: SiteSettings) => ProcessedMenuItem[] | null;

package/dist/menus/getCurrentLangMenus.js

@@ -0,0 +1,41 @@
+/*
+Get menus based on the current selected language
+*/
+export const getCurrentLangMenus = (settings) => {
+    if (!settings || !settings.menus || !settings.menus.length)
+        return null;
+    let currentLang = localStorage.getItem('i18nextLng');
+    // If no language is selected, use the default language
+    if (!currentLang) {
+        currentLang = settings.default_language.iso_code;
+    }
+    return settings.menus
+        .map((menu) => processMenuItem(menu, currentLang))
+        .filter((item) => item !== null);
+};
+/*
+Process a menu item and its children recursively:
+- Remove null items
+- Only keep fields that are needed from the translation for the current language
+- Remove other translations
+*/
+function processMenuItem(menuItem, currentLang) {
+    const translation = menuItem.translations[currentLang];
+    if (!translation) {
+        return null;
+    }
+    // Process children recursively and filter out null items
+    const children = menuItem.children && menuItem.children.length > 0
+        ? menuItem.children
+            .map((child) => processMenuItem(child, currentLang))
+            .filter((item) => item !== null)
+        : [];
+    return {
+        id: menuItem.id,
+        position: menuItem.position,
+        title: translation.title,
+        url: translation.url,
+        open_in_new_tab: translation.open_in_new_tab,
+        children,
+    };
+}

package/dist/menus/index.d.ts

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

package/dist/menus/index.js

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

package/dist/menus/types.d.ts

@@ -0,0 +1,22 @@
+export interface MenuItem {
+    id: number;
+    parent_id: number | null;
+    position: number;
+    translations: Record<string, {
+        open_in_new_tab: boolean;
+        page_content_id: number;
+        title: string;
+        url: string | null;
+        use_custom_url: boolean;
+        use_page_title: boolean;
+    }>;
+    children: MenuItem[];
+}
+export interface ProcessedMenuItem {
+    id: number;
+    position: number;
+    title: string;
+    url: string | null;
+    open_in_new_tab: boolean;
+    children: ProcessedMenuItem[];
+}

package/dist/menus/types.js

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

package/dist/page/constants.js

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

package/dist/page/fetchBlogListData.d.ts

@@ -0,0 +1,5 @@
+import type { ApiResponse } from './types';
+/**
+ * Fetches blog list data from the backend by language
+ */
+export declare function fetchBlogListData(lang: string, authToken?: string | null, astroRequest?: Request | null, backendHost?: string): Promise<ApiResponse>;

package/dist/page/fetchBlogListData.js

@@ -0,0 +1,75 @@
+/**
+ * Fetches blog list data from the backend by language
+ */
+export async function fetchBlogListData(lang, authToken = null, astroRequest = null, backendHost = 'http://localhost:8000') {
+    try {
+        // Determine the URL based on whether a language is provided
+        const url = lang && lang !== 'default'
+            ? `${backendHost}/blog_post/website/${lang}`
+            : `${backendHost}/blog_post/website/default`;
+        // Prepare fetch options
+        const fetchOptions = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        // Send the current hostname to the backend for proper domain detection
+        let hostname = null;
+        // Server-side: Extract hostname from Astro request
+        if (astroRequest) {
+            const url = new URL(astroRequest.url);
+            hostname = url.hostname;
+        }
+        // Client-side: Extract hostname from window
+        else if (typeof window !== 'undefined') {
+            hostname = window.location.hostname;
+        }
+        if (hostname) {
+            fetchOptions.headers['X-Original-Host'] = hostname;
+            fetchOptions.headers['X-Frontend-Host'] = hostname;
+            // Note: Cannot override Host header due to browser security restrictions
+        }
+        // Add authentication headers if token exists (for both preview and protected content)
+        let token = authToken;
+        // If no token provided and we're in browser environment, try Capacitor Preferences
+        if (!token && typeof window !== 'undefined') {
+            try {
+                const { Preferences } = await import('@capacitor/preferences');
+                const tokenResult = await Preferences.get({ key: 'token' });
+                token = tokenResult.value;
+            }
+            catch (e) {
+                console.warn('Could not get token from Preferences:', e);
+            }
+        }
+        if (token) {
+            fetchOptions.headers['Authorization'] = `Bearer ${token}`;
+        }
+        // Fetch the blog list data from the backend
+        const response = await fetch(url, fetchOptions);
+        // Handle authentication errors
+        if (response.status === 401) {
+            return { error: true, status: 401, message: 'Authentication required' };
+        }
+        // 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
+            const posts = await response.json();
+            return { posts };
+        }
+        catch (parseError) {
+            console.error(`Failed to parse response: ${parseError.message}`);
+            return { error: true, parseError: parseError.message };
+        }
+    }
+    catch (error) {
+        console.error('Error fetching blog list data:', error);
+        return { error: true, message: error.message };
+    }
+}

package/dist/page/fetchBlogPostData.d.ts

@@ -0,0 +1,5 @@
+import type { ApiResponse } from './types';
+/**
+ * Fetches Blog-Post-Content data from the backend by language and slug
+ */
+export declare function fetchBlogPostData(lang: string, slug: string, authToken?: string | null, astroRequest?: Request | null, backendHost?: string): Promise<ApiResponse>;

package/dist/page/fetchBlogPostData.js

@@ -0,0 +1,76 @@
+/**
+ * Fetches Blog-Post-Content data from the backend by language and slug
+ */
+export async function fetchBlogPostData(lang, slug, authToken = null, astroRequest = null, backendHost = 'http://localhost:8000') {
+    try {
+        // Format the slug properly
+        const formattedSlug = slug.replace(/^\/blog\//, '');
+        // Determine the URL based on whether a language is provided
+        const url = lang && lang !== 'default'
+            ? `${backendHost}/blog_post/website/${lang}/${formattedSlug}`
+            : `${backendHost}/blog_post/website/default/${formattedSlug}`;
+        // Prepare fetch options
+        const fetchOptions = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        // Send the current hostname to the backend for proper domain detection
+        let hostname = null;
+        // Server-side: Extract hostname from Astro request
+        if (astroRequest) {
+            const url = new URL(astroRequest.url);
+            hostname = url.hostname;
+        }
+        // Client-side: Extract hostname from window
+        else if (typeof window !== 'undefined') {
+            hostname = window.location.hostname;
+        }
+        if (hostname) {
+            fetchOptions.headers['X-Original-Host'] = hostname;
+            fetchOptions.headers['X-Frontend-Host'] = hostname;
+            // Note: Cannot override Host header due to browser security restrictions
+        }
+        // Add authentication headers if token exists (for both preview and protected content)
+        let token = authToken;
+        // If no token provided and we're in browser environment, try Capacitor Preferences
+        if (!token && typeof window !== 'undefined') {
+            try {
+                const { Preferences } = await import('@capacitor/preferences');
+                const tokenResult = await Preferences.get({ key: 'token' });
+                token = tokenResult.value;
+            }
+            catch (e) {
+                console.warn('Could not get token from Preferences:', e);
+            }
+        }
+        if (token) {
+            fetchOptions.headers['Authorization'] = `Bearer ${token}`;
+        }
+        // Fetch the page data from the backend
+        const response = await fetch(url, fetchOptions);
+        // Handle authentication errors
+        if (response.status === 401) {
+            return { error: true, status: 401, message: 'Authentication required' };
+        }
+        // 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/fetchFormData.d.ts

@@ -0,0 +1,5 @@
+import type { ApiResponse } from './types';
+/**
+ * Fetches Form data from the backend by language and slug
+ */
+export declare function fetchFormData(lang: string, slug: string, backendHost?: string): Promise<ApiResponse>;

package/dist/page/fetchFormData.js

@@ -0,0 +1,38 @@
+/**
+ * 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/fetchPageData.d.ts

@@ -0,0 +1,5 @@
+import type { ApiResponse } from './types';
+/**
+ * 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<ApiResponse>;

package/dist/page/fetchPageData.js

@@ -0,0 +1,104 @@
+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') {
+    try {
+        // Format the slug properly, make sure it starts with a slash
+        let formattedSlug = slug.startsWith('/') ? slug : `/${slug}`;
+        // Backend will consider 'default' as the home slug
+        if (formattedSlug === '/') {
+            formattedSlug = '/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}`;
+        }
+        // Add preview parameter if enabled
+        if (isPreview) {
+            url += '?preview=true';
+        }
+        // Prepare fetch options
+        const fetchOptions = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        // Send the current hostname to the backend for proper domain detection
+        let hostname = null;
+        // Server-side: Extract hostname from Astro request
+        if (astroRequest) {
+            const url = new URL(astroRequest.url);
+            hostname = url.hostname;
+        }
+        // Client-side: Extract hostname from window
+        else if (typeof window !== 'undefined') {
+            hostname = window.location.hostname;
+        }
+        if (hostname) {
+            fetchOptions.headers['X-Original-Host'] = hostname;
+            fetchOptions.headers['X-Frontend-Host'] = hostname;
+            // Note: Cannot override Host header due to browser security restrictions
+        }
+        // Add authentication headers if token exists (for both preview and protected content)
+        let token = authToken;
+        // If no token provided and we're in browser environment, try Capacitor Preferences
+        if (!token && typeof window !== 'undefined') {
+            try {
+                const { Preferences } = await import('@capacitor/preferences');
+                const tokenResult = await Preferences.get({ key: 'token' });
+                token = tokenResult.value;
+            }
+            catch (e) {
+                console.warn('Could not get token from Preferences:', e);
+            }
+        }
+        if (token) {
+            fetchOptions.headers['Authorization'] = `Bearer ${token}`;
+        }
+        // Fetch the page data from the backend
+        const response = await fetch(url, fetchOptions);
+        // Handle authentication errors
+        if (response.status === 401) {
+            return { error: true, status: 401, message: 'Authentication required' };
+        }
+        // Only treat actual 404 as not found
+        if (response.status === 404) {
+            const { detail } = await response.json();
+            console.warn('404', url, { detail });
+            // 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);
+                return { notFound: true, status: 404, detail };
+            }
+        }
+        try {
+            // Parse the JSON
+            const jsonData = await response.json();
+            return jsonData;
+        }
+        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/fetchPublicSettings.d.ts

@@ -0,0 +1,5 @@
+import type { SiteSettings } from '../types';
+/**
+ * Fetches public settings from the backend
+ */
+export declare function fetchPublicSettings(orgId?: number | null, astroRequest?: Request | null, lang?: string | null, backendHost?: string): Promise<SiteSettings | null>;

package/dist/page/fetchPublicSettings.js

@@ -0,0 +1,63 @@
+/**
+ * Fetches public settings from the backend
+ */
+export async function fetchPublicSettings(orgId = null, astroRequest = null, lang = null, backendHost = 'http://localhost:8000') {
+    try {
+        let url;
+        if (orgId === null) {
+            // Use domain-based detection when orgId is null
+            url = `${backendHost}/util/public_settings`;
+            if (lang) {
+                url += `?lang=${encodeURIComponent(lang)}`;
+            }
+        }
+        else {
+            // Handle server-side environment where localStorage is not available
+            let organizationId = orgId;
+            // Only access localStorage if we're in a browser environment and orgId not provided
+            if (typeof window !== 'undefined' && window.localStorage && !orgId) {
+                const storedOrgId = localStorage.getItem('organizationId');
+                organizationId = storedOrgId ? parseInt(storedOrgId) : 1;
+            }
+            url = `${backendHost}/util/public_settings/${organizationId}`;
+            if (lang) {
+                url += `?lang=${encodeURIComponent(lang)}`;
+            }
+        }
+        // Detect current hostname for domain-based organization detection
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // For domain-based detection, send the current hostname to the backend
+        if (orgId === null) {
+            let hostname = null;
+            // Server-side: Extract hostname from Astro request
+            if (astroRequest) {
+                const url = new URL(astroRequest.url);
+                hostname = url.hostname;
+            }
+            // Client-side: Extract hostname from window
+            else if (typeof window !== 'undefined') {
+                hostname = window.location.hostname;
+            }
+            if (hostname) {
+                headers['X-Original-Host'] = hostname;
+                headers['X-Frontend-Host'] = hostname;
+                // Note: Cannot override Host header due to browser security restrictions
+            }
+        }
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: headers,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+    catch (error) {
+        console.error('Error fetching public settings:', error);
+        return null;
+    }
+}

package/dist/page/getAuthToken.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extracts the authentication token from cookies or URL parameter (for iframe preview)
+ */
+export declare function getAuthToken(astro: any): any;

package/dist/page/getAuthToken.js

@@ -0,0 +1,17 @@
+/**
+ * Extracts the authentication token from cookies or URL parameter (for iframe preview)
+ */
+export function getAuthToken(astro) {
+    let authToken = null;
+    const cookies = astro.request.headers.get('cookie');
+    if (cookies) {
+        // Try different possible token cookie names
+        const tokenMatch = cookies.match(/(?:token|authToken|access_token|jwt)=([^;]+)/);
+        authToken = tokenMatch ? tokenMatch[1] : null;
+    }
+    // If no token from cookies, try URL parameter (for iframe preview)
+    if (!authToken) {
+        authToken = astro.url.searchParams.get('token');
+    }
+    return authToken;
+}

package/dist/page/index.d.ts

@@ -0,0 +1,8 @@
+export * from './fetchBlogListData.js';
+export * from './fetchBlogPostData.js';
+export * from './fetchFormData.js';
+export * from './fetchPageData.js';
+export * from './fetchPublicSettings.js';
+export * from './getAuthToken.js';
+export * from './parseSlugForLangAndPath.js';
+export * from './types.js';

package/dist/page/index.js

@@ -0,0 +1,8 @@
+export * from './fetchBlogListData.js';
+export * from './fetchBlogPostData.js';
+export * from './fetchFormData.js';
+export * from './fetchPageData.js';
+export * from './fetchPublicSettings.js';
+export * from './getAuthToken.js';
+export * from './parseSlugForLangAndPath.js';
+export * from './types.js';

package/dist/page/parseSlugForLangAndPath.d.ts

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

package/dist/page/parseSlugForLangAndPath.js

@@ -0,0 +1,22 @@
+import { isValidLanguageCode } from '../language';
+/**
+ * Parses a slug to determine language and path
+ */
+export function parseSlugForLangAndPath(slug) {
+    const slugParts = slug ? slug.split('/').filter(Boolean) : [];
+    let lang = null;
+    let path = '/';
+    // Check if the first part is a valid language code
+    if (slugParts.length > 0 && isValidLanguageCode(slugParts[0])) {
+        lang = slugParts[0];
+        // If there are more parts, join them as the path, otherwise keep root path
+        if (slugParts.length > 1) {
+            path = '/' + slugParts.slice(1).join('/');
+        }
+    }
+    else {
+        // No language in URL, use the path as is with a leading slash
+        path = slugParts.length > 0 ? '/' + slugParts.join('/') : '/';
+    }
+    return { lang, path };
+}

package/dist/page/types.d.ts

@@ -0,0 +1,21 @@
+export interface SlugParseResult {
+    lang: string | null;
+    path: string;
+}
+export interface ErrorResponse {
+    error: true;
+    status?: number;
+    message?: string;
+    parseError?: string;
+}
+export interface NotFoundResponse {
+    notFound: true;
+    status: number;
+    detail: string;
+    public_settings?: Record<string, unknown>;
+    lang?: string;
+}
+export interface BlogListResponse {
+    posts: Record<string, unknown>[];
+}
+export type ApiResponse = Record<string, unknown> | ErrorResponse | NotFoundResponse | BlogListResponse;

package/dist/page/types.js

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

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+import type { MenuItem } from './menus/types';
+export interface SiteSettings {
+    domains: string[];
+    available_languages: Array<{
+        id: number;
+        name: string;
+        iso_code: string;
+        emoji_flag: string;
+    }>;
+    default_language: {
+        id: number;
+        name: string;
+        iso_code: string;
+        emoji_flag: string;
+    };
+    auto_translate_pages: boolean;
+    auto_translate_posts: boolean;
+    has_openrouter_api_key: boolean;
+    ai_autocomplete_model_id: number;
+    show_post_author: boolean;
+    show_post_date: boolean;
+    show_chatbox: boolean;
+    website_custom_code: string | null;
+    menus: MenuItem[];
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@deepsel/cms-utils",
+  "version": "1.0.0",
+  "description": "Helper utilities for DeepCMS",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DeepselSystems/cms-utils.git"
+  },
+  "author": "Tim Tran <tim.tran@deepsel.com> (https://deepsel.com)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/DeepselSystems/cms-utils/issues"
+  },
+  "homepage": "https://github.com/DeepselSystems/cms-utils#readme",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint \"{src,tests}/**/*.ts\"",
+    "lint:fix": "eslint \"{src,tests}/**/*.ts\" --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepush": "npm run test && npm run build && npm run lint && npm run format:check",
+    "publish": "npm publish --access public"
+  },
+  "keywords": [
+    "cms",
+    "utils",
+    "deepsel",
+    "typescript",
+    "helper",
+    "content-management"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.0",
+    "eslint": "^9.39.1",
+    "eslint-plugin-vitest": "^0.5.4",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vitest": "^4.0.8"
+  },
+  "dependencies": {
+    "@capacitor/preferences": "^7.0.2"
+  }
+}