@contentstorage/core 0.3.32 → 0.3.34

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { AppConfig, LanguageCode, ContentStructure } from './types.js';
-import { setContentLanguage, getText, getImage, getVariation } from './lib/contentManagement.js';
+import { setContentLanguage, getText, getImage, getVariation, initContentStorage } from './lib/contentManagement.js';
+import { fetchContent } from './lib/functions/fetchContent.js';
 export { AppConfig, LanguageCode, ContentStructure };
-export { setContentLanguage, getText, getImage, getVariation };
+export { initContentStorage, fetchContent, setContentLanguage, getText, getImage, getVariation, };

package/dist/index.js

@@ -1,2 +1,50 @@
-import { setContentLanguage, getText, getImage, getVariation, } from './lib/contentManagement.js';
-export { setContentLanguage, getText, getImage, getVariation };
+import { setContentLanguage, getText, getImage, getVariation, initContentStorage, } from './lib/contentManagement.js';
+import { fetchContent } from './lib/functions/fetchContent.js';
+export { initContentStorage, fetchContent, setContentLanguage, getText, getImage, getVariation, };
+async function isLiveEditorMode() {
+    try {
+        const inIframe = window.self !== window.top;
+        const urlParams = new URLSearchParams(window.location.search);
+        const iframeMarkerFromParent = urlParams.get('contentstorage_live_editor');
+        return !!(inIframe && iframeMarkerFromParent);
+    }
+    catch (e) {
+        // This catch block is for rare edge cases or highly sandboxed environments
+        // where accessing window.top might throw an error.
+        // If an error occurs, it's safer to assume it might be in an iframe.
+        console.warn('Error accessing window.top, assuming iframe context:', e);
+        return false;
+    }
+}
+isLiveEditorMode().then(async (isLiveMode) => {
+    if (!isLiveMode) {
+        return;
+    }
+    const cdnScriptUrl = `https://your-cdn-domain.com/contentstorage-live-editor.js?contentstorage-live-editor=true`;
+    return new Promise((resolve, reject) => {
+        console.log(`Attempting to load script from: ${cdnScriptUrl}`);
+        // 1. Create a new <script> element
+        const scriptElement = document.createElement('script');
+        scriptElement.type = 'text/javascript';
+        // 2. Set the src attribute to your script's URL
+        // The browser will fetch and execute it.
+        scriptElement.src = cdnScriptUrl;
+        // 3. Handle successful loading
+        scriptElement.onload = () => {
+            console.log(`Script loaded successfully from: ${cdnScriptUrl}`);
+            // The script has been fetched and executed by the browser.
+            // If it's an IIFE, it has already run.
+            resolve(true); // Resolve the promise indicating success
+        };
+        // 4. Handle errors during loading (e.g., network error, 404)
+        scriptElement.onerror = (error) => {
+            console.error(`Failed to load script from: ${cdnScriptUrl}`, error);
+            reject(new Error(`Failed to load script: ${cdnScriptUrl}`)); // Reject the promise
+        };
+        // 5. Append the script element to the document's head (or body)
+        // This triggers the browser to start loading the script.
+        document.head.appendChild(scriptElement);
+        // Or: document.body.appendChild(scriptElement);
+    });
+    // fetch script to handle iframe communication
+});

package/dist/lib/contentManagement.d.ts

@@ -1,25 +1,27 @@
-import { ContentStructure, ImageObject } from '../types.js';
+import { AppConfig, ContentStructure, GetImageReturn, GetTextReturn, GetVariationReturn } from '../types.js';
+export declare let activeContent: object | null;
+export declare let appConfig: AppConfig | null;
 /**
  * Loads and sets the content for a specific language.
  * It will internally ensure the application configuration (for contentDir) is loaded.
  * @param contentJson
  */
 export declare function setContentLanguage(contentJson: object): void;
+export declare function initContentStorage(config: AppConfig): void;
 /**
  * Retrieves the text string from the loaded JSON content for the given path.
  * Autocompletion for pathString is enabled via module augmentation of CustomContentStructure.
  * `setContentLanguage()` must be called successfully before using this.
  *
- * @param pathString A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
+ * @param contentKey A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
  * @param variables Variables help to render dynamic content inside text strings
- * @param fallbackValue Optional string to return if the path is not found or the value is not a string.
  * If not provided, and path is not found/value not string, undefined is returned.
  * @returns The text string from the JSON, or the fallbackValue, or undefined.
  */
-export declare function getText<Path extends keyof ContentStructure>(pathString: Path, variables?: ContentStructure[Path] extends {
+export declare function getText<Path extends keyof ContentStructure>(contentKey: Path, variables?: ContentStructure[Path] extends {
     variables: infer Vars;
-} ? keyof Vars : Record<string, any>): string | undefined;
-export declare function getImage(pathString: keyof ContentStructure, fallbackValue?: ImageObject): ImageObject | undefined;
-export declare function getVariation<Path extends keyof ContentStructure>(pathString: Path, variationKey?: ContentStructure[Path] extends {
+} ? keyof Vars : Record<string, any>): GetTextReturn;
+export declare function getImage(contentKey: keyof ContentStructure): GetImageReturn | undefined;
+export declare function getVariation<Path extends keyof ContentStructure>(contentKey: Path, variationKey?: ContentStructure[Path] extends {
     data: infer D;
-} ? keyof D : string, variables?: Record<string, any>): string | undefined;
+} ? keyof D : string, variables?: Record<string, any>): GetVariationReturn;

package/dist/lib/contentManagement.js

@@ -1,5 +1,6 @@
 import { populateTextWithVariables } from '../helpers/populateTextWithVariables.js';
-let activeContent = null;
+export let activeContent = null;
+export let appConfig = null;
 /**
  * Loads and sets the content for a specific language.
  * It will internally ensure the application configuration (for contentDir) is loaded.
@@ -18,94 +19,131 @@ export function setContentLanguage(contentJson) {
         console.error(`[Contentstorage] Failed to load content. Error: ${error.message}`);
     }
 }
+export function initContentStorage(config) {
+    if (!config ||
+        typeof config !== 'object' ||
+        !config.contentKey ||
+        !Array.isArray(config.languageCodes)) {
+        if (!config.contentKey) {
+            throw new Error('[Contentstorage] No contentKey provided in initContentStorage function.');
+        }
+        if (!Array.isArray(config.languageCodes)) {
+            throw new Error('[Contentstorage] No languageCodes provided in initContentStorage function.');
+        }
+        throw new Error('[Contentstorage] Invalid config.');
+    }
+    appConfig = config;
+}
 /**
  * Retrieves the text string from the loaded JSON content for the given path.
  * Autocompletion for pathString is enabled via module augmentation of CustomContentStructure.
  * `setContentLanguage()` must be called successfully before using this.
  *
- * @param pathString A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
+ * @param contentKey A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
  * @param variables Variables help to render dynamic content inside text strings
- * @param fallbackValue Optional string to return if the path is not found or the value is not a string.
  * If not provided, and path is not found/value not string, undefined is returned.
  * @returns The text string from the JSON, or the fallbackValue, or undefined.
  */
-export function getText(pathString, variables) {
+export function getText(contentKey, variables) {
+    const defaultVal = {
+        contentKey,
+        text: '',
+    };
     if (!activeContent) {
-        const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(contentKey)}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return '';
+        return defaultVal;
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getText: Path "${String(pathString)}" not found in loaded content.`;
+            const msg = `[Contentstorage] getText: Path "${String(contentKey)}" not found in loaded content.`;
             console.warn(msg);
-            return '';
+            return defaultVal;
         }
     }
     if (typeof current === 'string') {
         if (!variables || Object.keys(variables).length === 0) {
-            return current;
+            return {
+                contentKey,
+                text: current,
+            };
         }
-        return populateTextWithVariables(current, variables, pathString);
+        return {
+            contentKey,
+            text: populateTextWithVariables(current, variables, contentKey),
+        };
     }
     else {
-        const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
+        const msg = `[Contentstorage] getText: Value at path "${String(contentKey)}" is not a string (actual type: ${typeof current}).`;
         console.warn(msg);
-        return '';
+        return defaultVal;
     }
 }
-export function getImage(pathString, fallbackValue) {
+export function getImage(contentKey) {
+    const defaultVal = {
+        contentKey,
+        data: { url: '', altText: '', contentstorage_type: 'image' },
+    };
     if (!activeContent) {
-        const msg = `[Contentstorage] getImage: Content not loaded (Key: "${pathString}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getImage: Content not loaded (Key: "${contentKey}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return fallbackValue;
+        return {
+            contentKey,
+            data: { url: '', altText: '', contentstorage_type: 'image' },
+        };
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getImage: Path "${pathString}" not found in loaded content.`;
+            const msg = `[Contentstorage] getImage: Path "${contentKey}" not found in loaded content.`;
             console.warn(msg);
-            return fallbackValue;
+            return defaultVal;
         }
     }
     if (current &&
         typeof current === 'object' &&
         current.contentstorage_type === 'image' &&
-        typeof current.url === 'string' &&
-        typeof current.altText === 'string') {
-        return current;
+        typeof current.url === 'string') {
+        return {
+            contentKey,
+            data: current,
+        };
     }
     else {
-        const msg = `[Contentstorage] getImage: Value at path "${pathString}" is not a valid image object (actual value: ${JSON.stringify(current)}).`;
+        const msg = `[Contentstorage] getImage: Value at path "${contentKey}" is not a valid image object (actual value: ${JSON.stringify(current)}).`;
         console.warn(msg);
-        return fallbackValue;
+        return defaultVal;
     }
 }
-export function getVariation(pathString, variationKey, variables) {
+export function getVariation(contentKey, variationKey, variables) {
+    const defaultVal = {
+        contentKey,
+        text: '',
+    };
     if (!activeContent) {
-        const msg = `[Contentstorage] getVariation: Content not loaded (Key: "${pathString}", Variation: "${variationKey?.toString()}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getVariation: Content not loaded (Key: "${contentKey}", Variation: "${variationKey?.toString()}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return '';
+        return defaultVal;
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getVariation: Path "${pathString}" for variation object not found in loaded content.`;
+            const msg = `[Contentstorage] getVariation: Path "${contentKey}" for variation object not found in loaded content.`;
             console.warn(msg);
-            return '';
+            return defaultVal;
         }
     }
     if (current &&
@@ -120,12 +158,18 @@ export function getVariation(pathString, variationKey, variables) {
             if (typeof variationObject.data[variationKey] === 'string') {
                 const current = variationObject.data[variationKey];
                 if (!variables || Object.keys(variables).length === 0) {
-                    return current;
+                    return {
+                        contentKey,
+                        text: current,
+                    };
                 }
-                return populateTextWithVariables(current, variables, pathString);
+                return {
+                    contentKey,
+                    text: populateTextWithVariables(current, variables, contentKey),
+                };
             }
             else {
-                const msg = `[Contentstorage] getVariation: Variation value for key "${variationKey}" at path "${pathString}" is not a string (actual type: ${typeof variationObject.data[variationKey]}).`;
+                const msg = `[Contentstorage] getVariation: Variation value for key "${variationKey}" at path "${contentKey}" is not a string (actual type: ${typeof variationObject.data[variationKey]}).`;
                 console.warn(msg);
             }
         }
@@ -133,20 +177,23 @@ export function getVariation(pathString, variationKey, variables) {
         if ('default' in variationObject.data && typeof variationKey === 'string') {
             if (typeof variationObject.data.default === 'string') {
                 if (variationKey && variationKey !== 'default') {
-                    console.warn(`[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${pathString}". Returning 'default' variation.`);
+                    console.warn(`[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${contentKey}". Returning 'default' variation.`);
                 }
-                return variationObject.data.default;
+                return {
+                    contentKey,
+                    text: variationObject.data.default,
+                };
             }
             else {
-                console.warn(`[Contentstorage] getVariation: 'default' variation value at path "${pathString}" is not a string (actual type: ${typeof variationObject.data.default}).`);
+                console.warn(`[Contentstorage] getVariation: 'default' variation value at path "${contentKey}" is not a string (actual type: ${typeof variationObject.data.default}).`);
             }
         }
         // If neither specific key nor 'default' is found or valid
-        console.warn(`[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${pathString}".`);
-        return '';
+        console.warn(`[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${contentKey}".`);
+        return defaultVal;
     }
     else {
-        console.warn(`[Contentstorage] getVariation: Value at path "${pathString}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`);
-        return '';
+        console.warn(`[Contentstorage] getVariation: Value at path "${contentKey}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`);
+        return defaultVal;
     }
 }

package/dist/lib/functions/fetchContent.d.ts

@@ -0,0 +1,2 @@
+import { LanguageCode } from '../../types.js';
+export declare function fetchContent(language?: LanguageCode): Promise<void>;

package/dist/lib/functions/fetchContent.js

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { CONTENTSTORAGE_CONFIG } from '../../contentstorage-config.js';
+import { appConfig, setContentLanguage } from '../contentManagement.js';
+export async function fetchContent(language) {
+    const languageToFetch = language || appConfig?.languageCodes?.[0];
+    console.log(`Starting content fetch for language ${language}...`);
+    if (!languageToFetch) {
+        throw Error(`No language found`);
+    }
+    if (!appConfig) {
+        throw Error(`No app config found`);
+    }
+    const fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${appConfig.contentKey}/content/${languageToFetch}.json`;
+    try {
+        // Fetch data for the current language
+        const response = await axios.get(fileUrl);
+        const jsonData = response.data;
+        // Basic check for data existence, although axios usually throws for non-2xx responses
+        if (jsonData === undefined || jsonData === null) {
+            throw new Error(`No data received from ${fileUrl} for language ${languageToFetch}.`);
+        }
+        // Validate that jsonData is a single, non-null JSON object (not an array)
+        // This check mirrors the original code's expectation for the content of a JSON file.
+        if (typeof jsonData !== 'object') {
+            throw new Error(`Expected a single JSON object from ${fileUrl} for language ${languageToFetch}, but received type ${typeof jsonData}. Cannot proceed.`);
+        }
+        console.log(`Received JSON for ${languageToFetch}`);
+        setContentLanguage(jsonData);
+    }
+    catch (error) {
+        // Catch errors related to fetching or saving a single language file
+        console.error(`\nError processing language ${languageToFetch} from ${fileUrl}:`);
+        if (axios.isAxiosError(error)) {
+            console.error(`  Status: ${error.response?.status}`);
+            console.error(`Response Data: ${error.response?.data ? JSON.stringify(error.response.data) : 'N/A'}`);
+            console.error(`  Message: ${error.message}`); // Axios error message
+        }
+        else {
+            // For non-Axios errors (e.g., manually thrown errors, fs errors)
+            console.error(`  Error: ${error.message}`);
+        }
+    }
+}

package/dist/types.d.ts

@@ -22,6 +22,18 @@ export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL'
  */
 export interface ContentStructure {
 }
+export type GetTextReturn = {
+    contentKey: string;
+    text: string;
+};
+export type GetImageReturn = {
+    contentKey: string;
+    data: ImageObject;
+};
+export type GetVariationReturn = {
+    contentKey: string;
+    text: string;
+};
 export interface ImageObject {
     contentstorage_type: 'image';
     url: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.32",
+  "version": "0.3.34",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",