@contentstorage/core 0.3.11 → 0.3.12

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 import { AppConfig, LanguageCode } from './types.js';
+import { setContentLanguage, getCurrentLanguage, getText } from './lib/contentManagement.js';
 export { AppConfig, LanguageCode };
+export { setContentLanguage, getText, getCurrentLanguage };

package/dist/index.js

@@ -1 +1,2 @@
-export {};
+import { setContentLanguage, getCurrentLanguage, getText, } from './lib/contentManagement.js';
+export { setContentLanguage, getText, getCurrentLanguage };

package/dist/lib/contentManagement.d.ts

@@ -0,0 +1,23 @@
+import { DotNotationPaths } from '../types.js';
+/**
+ * Loads and sets the content for a specific language.
+ * It will internally ensure the application configuration (for contentDir) is loaded.
+ * @param languageCode The language code (e.g., 'EN', 'FR') for the JSON file to load.
+ */
+export declare function setContentLanguage(languageCode: string): Promise<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 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(pathString: DotNotationPaths, fallbackValue?: string): string | undefined;
+/**
+ * Gets the currently active language code.
+ * @returns The active language code or null if no language is set.
+ */
+export declare function getCurrentLanguage(): string | null;

package/dist/lib/contentManagement.js

@@ -0,0 +1,101 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadConfig } from './configLoader.js';
+let activeContent = null;
+let activeLanguage = null;
+let loadedAppConfig = null; // Cache for the loaded config
+/**
+ * Ensures the application configuration (especially contentDir) is loaded.
+ * Calls your library's loadConfig function.
+ */
+async function ensureConfigInitialized() {
+    if (loadedAppConfig) {
+        return loadedAppConfig;
+    }
+    try {
+        const config = await loadConfig(); // This is your library's function
+        if (!config || !config.contentDir) {
+            throw new Error('contentDir not found in the loaded configuration (contentstorage.config.js).');
+        }
+        loadedAppConfig = config; // Ensure it matches the expected structure
+        console.log(`[LocalizationLibrary] Configuration loaded. Content directory set to: ${loadedAppConfig.contentDir}`);
+        return loadedAppConfig;
+    }
+    catch (error) {
+        console.error('[Contentstorage] Failed to initialize configuration:', error);
+        throw new Error(`[Contentstorage] Critical error: Could not load or validate app configuration. ${error.message}`);
+    }
+}
+/**
+ * Loads and sets the content for a specific language.
+ * It will internally ensure the application configuration (for contentDir) is loaded.
+ * @param languageCode The language code (e.g., 'EN', 'FR') for the JSON file to load.
+ */
+export async function setContentLanguage(languageCode) {
+    if (!languageCode ||
+        typeof languageCode !== 'string' ||
+        languageCode.trim() === '') {
+        throw new Error('[Contentstorage] Invalid language code provided to setContentLanguage.');
+    }
+    const config = await ensureConfigInitialized(); // Gets contentDir from loaded config
+    const targetFilename = `${languageCode}.json`;
+    const jsonFilePath = path.join(config.contentDir, targetFilename);
+    console.log(`[Contentstorage] Attempting to load content for language '${languageCode}' from ${jsonFilePath}...`);
+    try {
+        const jsonContentString = await fs.readFile(jsonFilePath, 'utf-8');
+        activeContent = JSON.parse(jsonContentString); // Relies on augmentation
+        activeLanguage = languageCode;
+        console.log(`[Contentstorage] Content for language '${languageCode}' loaded successfully.`);
+    }
+    catch (error) {
+        activeContent = null; // Reset on failure
+        console.error(`[Contentstorage] Failed to load content for language '${languageCode}' from ${jsonFilePath}. Error: ${error.message}`);
+        throw new Error(`[Contentstorage] Could not load content for language: ${languageCode}. Ensure file exists at '${jsonFilePath}' and is valid JSON.`);
+    }
+}
+/**
+ * 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 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(
+// @ts-expect-error Is fine
+pathString, fallbackValue) {
+    if (!activeContent) {
+        const msg = `[Contentstorage] getText: Content not loaded (Path: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
+        console.warn(msg);
+        return fallbackValue;
+    }
+    const keys = pathString.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 for language '${activeLanguage}'.`;
+            console.warn(msg);
+            return fallbackValue;
+        }
+    }
+    if (typeof current === 'string') {
+        return current;
+    }
+    else {
+        const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
+        console.warn(msg);
+        return fallbackValue;
+    }
+}
+/**
+ * Gets the currently active language code.
+ * @returns The active language code or null if no language is set.
+ */
+export function getCurrentLanguage() {
+    return activeLanguage;
+}

package/dist/scripts/generate-types.js

@@ -44,7 +44,7 @@ export async function generateTypes() {
         }
         // Generate TypeScript interfaces using json-to-ts
         // The root type name for the generated interface. You might want to make this configurable.
-        const rootTypeName = 'RootContentItem';
+        const rootTypeName = 'ContentRoot';
         const typeDeclarations = jsonToTS.default(jsonObject, {
             rootName: rootTypeName,
         });

package/dist/types.d.ts

@@ -5,3 +5,31 @@ export type AppConfig = {
     typesOutputFile: string;
 };
 export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL' | 'EN' | 'ET' | 'FI' | 'FR' | 'DE' | 'EL' | 'HU' | 'GA' | 'IT' | 'LV' | 'LT' | 'MK' | 'NO' | 'PL' | 'PT' | 'RO' | 'RU' | 'SR' | 'SK' | 'SL' | 'ES' | 'SV' | 'TR' | 'UK';
+/**
+ * This interface is intended to be augmented by the consumer application.
+ * By augmenting this interface with their specific RootContentItem type,
+ * consumers enable type-safe autocompletion for localization path strings
+ * used with functions like `getText`.
+ *
+ * @example
+ * // In consumer's project (e.g., in a .d.ts file):
+ * import 'your-library-name'; // Your library's package name
+ * import type { RootContentItem as AppSpecificRootItem } from './generated_content_types';
+ *
+ * declare module 'your-library-name' {
+ * export interface ContentStructure extends AppSpecificRootItem {}
+ * }
+ */
+export interface ContentStructure {
+    [key: string]: any;
+}
+/**
+ * Generates a union of all possible dot-notation path strings for a given object type `T`.
+ * Defaults to using the `ContentStructure` interface, which consumers augment.
+ *
+ * @template T The object type to generate paths from. Defaults to `ContentStructure`.
+ * @template Prefix Internal accumulator for the current path prefix during recursion.
+ */
+export type DotNotationPaths<T = ContentStructure, Prefix extends string = ''> = T extends object ? {
+    [K in keyof T]-?: K extends string | number ? T[K] extends object ? `${Prefix}${K}` | DotNotationPaths<T[K], `${Prefix}${K}.`> : `${Prefix}${K}` : never;
+}[keyof T] : '';

package/package.json

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