@contentstorage/core 0.3.10 → 0.3.12

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,2 +1,2 @@
-import { defineConfig } from './helpers/defineConfig.js';
-export { defineConfig };
+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

@@ -7,52 +7,56 @@ import chalk from 'chalk'; // Optional: for colored output
 import { loadConfig } from '../lib/configLoader.js';
 export async function generateTypes() {
     console.log(chalk.blue('Starting type generation...'));
-    const config = await loadConfig();
-    console.log(chalk.gray(`Reading JSON files from: ${config.contentDir}`));
+    const config = await loadConfig(); // Ensure loadConfig provides languageCodes
+    console.log(chalk.gray(`Content will be read from directory: ${config.contentDir}`));
     console.log(chalk.gray(`Saving TypeScript types to: ${config.typesOutputFile}`));
     try {
-        // Read the content directory
-        let files;
+        // Validate languageCodes from config
+        if (!config.languageCodes ||
+            !Array.isArray(config.languageCodes) ||
+            config.languageCodes.length === 0) {
+            throw new Error('config.languageCodes is missing, not an array, or empty. Cannot determine which JSON file to use for type generation.');
+        }
+        const firstLanguageCode = config.languageCodes[0];
+        const targetFilename = `${firstLanguageCode}.json`;
+        const jsonFilePath = path.join(config.contentDir, targetFilename);
+        console.log(chalk.gray(`Attempting to generate types using the JSON file for the first configured language code ('${firstLanguageCode}').`));
+        console.log(chalk.gray(`Target file: ${jsonFilePath}`));
+        // Read the specific JSON file
+        let jsonContent;
         try {
-            files = await fs.readdir(config.contentDir);
+            jsonContent = await fs.readFile(jsonFilePath, 'utf-8');
         }
         catch (err) {
             if (err.code === 'ENOENT') {
-                throw new Error(`Content directory not found: ${config.contentDir}. Run 'pull-content' first?`);
+                throw new Error(`Target JSON file not found: ${jsonFilePath}. Ensure content for language code '${firstLanguageCode}' has been pulled and exists at this location.`);
             }
-            throw err; // Re-throw other errors
-        }
-        // Filter for JSON files and sort them (optional, but good for consistency)
-        const jsonFiles = files
-            .filter((file) => file.toLowerCase().endsWith('.json'))
-            .sort();
-        if (jsonFiles.length === 0) {
-            throw new Error(`No JSON files found in ${config.contentDir}.`);
+            // Re-throw other fs.readFile errors (e.g., permission issues)
+            throw new Error(`Failed to read file ${jsonFilePath}: ${err.message}`);
         }
-        const firstJsonFile = jsonFiles[0];
-        const jsonFilePath = path.join(config.contentDir, firstJsonFile);
-        console.log(chalk.gray(`Using first JSON file for type generation: ${firstJsonFile}`));
-        // Read the first JSON file
-        const jsonContent = await fs.readFile(jsonFilePath, 'utf-8');
         // Parse the JSON content
         let jsonObject;
         try {
             jsonObject = JSON.parse(jsonContent);
         }
         catch (parseError) {
-            throw new Error(`Failed to parse JSON file ${firstJsonFile}: ${parseError.message}`);
+            throw new Error(`Failed to parse JSON from file ${targetFilename}: ${parseError.message}`);
         }
         // Generate TypeScript interfaces using json-to-ts
-        // jsonToTS returns an array of strings, each being a line of the interface/type
-        // We need to give the root type a name.
-        const rootTypeName = 'RootContentItem'; // Or derive from filename, or make configurable
+        // The root type name for the generated interface. You might want to make this configurable.
+        const rootTypeName = 'ContentRoot';
         const typeDeclarations = jsonToTS.default(jsonObject, {
             rootName: rootTypeName,
         });
+        // If your previous code `jsonToTS.default(...)` was correct for your setup,
+        // please revert the line above to:
+        // const typeDeclarations: string[] = jsonToTS.default(jsonObject, {
+        //   rootName: rootTypeName,
+        // });
         if (!typeDeclarations || typeDeclarations.length === 0) {
-            throw new Error(`Could not generate types from ${firstJsonFile}. Is the file empty or malformed?`);
+            throw new Error(`Could not generate types from ${targetFilename}. The file might be empty, malformed, or not produce any types.`);
         }
-        const outputContent = typeDeclarations.join('\n\n'); // Add extra newline between interfaces
+        const outputContent = typeDeclarations.join('\n\n'); // Add extra newline between interfaces for readability
         // Ensure the output directory exists
         const outputDir = path.dirname(config.typesOutputFile);
         await fs.mkdir(outputDir, { recursive: true });
@@ -61,8 +65,12 @@ export async function generateTypes() {
         console.log(chalk.green(`TypeScript types generated successfully at ${config.typesOutputFile}`));
     }
     catch (error) {
-        console.error(chalk.red('Error generating TypeScript types:'));
+        console.error(chalk.red.bold('\nError generating TypeScript types:'));
         console.error(chalk.red(error.message));
+        // It's good practice to log the stack for unexpected errors if not already done by a higher-level handler
+        // if (error.stack) {
+        //   console.error(chalk.gray(error.stack));
+        // }
         process.exit(1); // Exit with error code
     }
 }

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.10",
+  "version": "0.3.12",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",